Differences

This shows you the differences between two versions of the page.

--- thinkgeo.mapsuite.core.featuresource [2015/09/21 07:43]
admin
+++ thinkgeo.mapsuite.core.featuresource [2017/03/16 21:59] (current)
@@ Line 1: / Line 1: @@
 ====== ThinkGeo.MapSuite.Core.FeatureSource ======
+{{section>upgrade_map_suite_to_10.0}}
 The abstract class from which all feature sources inherit. Feature sources represent feature data that can be integrated into Map Suite.This class is key, as it is the abstract class from which all other feature sources are derived. In this sense it encapsulates much of the logic for handling transactions and ensuring the data is consistent regardless of any projections applied.
 ===== Inheritance Hierarchy =====
@@ Line 5: / Line 8: @@
     ***ThinkGeo.MapSuite.Core.FeatureSource**
       *[[ThinkGeo.MapSuite.Core.CadFeatureSource]]
+      *[[ThinkGeo.MapSuite.Core.CloudFileFeatureSource]]
       *[[ThinkGeo.MapSuite.Core.WkbFileFeatureSource]]
+      *[[ThinkGeo.MapSuite.Core.DelimitedFeatureSource]]
       *[[ThinkGeo.MapSuite.Core.GpxFeatureSource]]
       *[[ThinkGeo.MapSuite.Core.KmlFeatureSource]]
@@ Line 28: / Line 33: @@
 ** {{wiki:ProtectedMethod.gif|}} FeatureSource() **
-This is the default constructor for the abstract FeatureSource class.
+  * //This is the default constructor for the abstract FeatureSource class.//
 == Remarks ==
-As this method is protected, you may only add code to this method if you override it from an inheriting class.
+  * //As this method is protected, you may only add code to this method if you override it from an inheriting class.//
 == Parameters ==
 <div newline></div>
@@ Line 36: / Line 41: @@
 ** {{wiki:PublicMethod.gif|}} GetBoundingBox() **
-This method returns the bounding box which encompasses all of the features in the FeatureSource.
+  * //This method returns the bounding box which encompasses all of the features in the FeatureSource.//
 == Remarks ==
-This method is the concrete wrapper for the virtual method GetBoundingBoxCore. It will return whatever is returned by the GetBoundingBoxCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetBoundingBoxCore method is, please see the documentation for it. The default implementation of GetBoundingBoxCore uses the GetAllRecordsCore method to calculate the bounding box of the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the virtual method GetBoundingBoxCore. It will return whatever is returned by the GetBoundingBoxCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetBoundingBoxCore method is, please see the documentation for it. The default implementation of GetBoundingBoxCore uses the GetAllRecordsCore method to calculate the bounding box of the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 48: / Line 53: @@
 ** {{wiki:PublicMethod.gif|}} CloneDeep() **
-Create a copy of a FeatureSource using the deep clone process.
+  * //Create a copy of a FeatureSource using the deep clone process.//
 == Remarks ==
-The difference between deep clone and shallow clone is as follows: In shallow cloning, only the object is copied; the objects within it are not. By contrast, deep cloning copies the cloned object as well as all the objects within.
+  * //The difference between deep clone and shallow clone is as follows: In shallow cloning, only the object is copied; the objects within it are not. By contrast, deep cloning copies the cloned object as well as all the objects within.//
 == Return Value ==
@@ Line 60: / Line 65: @@
 ** {{wiki:PublicMethod.gif|}} Open() **
-This method opens the FeatureSource so that it is initialized and ready to use.
+  * //This method opens the FeatureSource so that it is initialized and ready to use.//
 == Remarks ==
-This method is the concrete wrapper for the abstract method OpenCore. The Open method plays an important role, as it is responsible for initializing the FeatureSource. Most methods on the FeatureSource will throw an exception if the state of the FeatureSource is not opened. When the map draws each layer, it will open the FeatureSource as one of its first steps, then after it is finished drawing with that layer it will close it. In this way we are sure to release all resources used by the FeatureSource. When implementing the abstract method, consider opening files for file-based sources, connecting to databases in the database-based sources and so on. You will get a chance to close these in the Close method of the FeatureSource. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the abstract method OpenCore. The Open method plays an important role, as it is responsible for initializing the FeatureSource. Most methods on the FeatureSource will throw an exception if the state of the FeatureSource is not opened. When the map draws each layer, it will open the FeatureSource as one of its first steps, then after it is finished drawing with that layer it will close it. In this way we are sure to release all resources used by the FeatureSource. When implementing the abstract method, consider opening files for file-based sources, connecting to databases in the database-based sources and so on. You will get a chance to close these in the Close method of the FeatureSource. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 72: / Line 77: @@
 ** {{wiki:PublicMethod.gif|}} Close() **
-This method closes the FeatureSource and releases any resources it was using.
+  * //This method closes the FeatureSource and releases any resources it was using.//
 == Remarks ==
-This method is the concrete wrapper for the abstract method CloseCore. The Close method plays an important role in the life cycle of the FeatureSource. It may be called after drawing to release any memory and other resources that were allocated since the Open method was called. If you override the Core version of this method, it is recommended that you take the following things into account: This method may be called multiple times, so we suggest you write the method so that that a call to a closed FeatureSource is ignored and does not generate an error. We also suggest that in the Close you free all resources that have been opened. Remember that the object will not be destroyed, but will be re-opened possibly in the near future. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the abstract method CloseCore. The Close method plays an important role in the life cycle of the FeatureSource. It may be called after drawing to release any memory and other resources that were allocated since the Open method was called. If you override the Core version of this method, it is recommended that you take the following things into account: This method may be called multiple times, so we suggest you write the method so that that a call to a closed FeatureSource is ignored and does not generate an error. We also suggest that in the Close you free all resources that have been opened. Remember that the object will not be destroyed, but will be re-opened possibly in the near future. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 84: / Line 89: @@
 ** {{wiki:PublicMethod.gif|}} BeginTransaction() **
-This method starts a new transaction if the FeasuteSource allows editing
+  * //This method starts a new transaction if the FeasuteSource allows editing//
 == Remarks ==
-This method is used to start a transaction, assuming that the FeatureSource allows editing. There are some additional prerequisites to beginning a transaction, such as ensuring that a transaction is not already in progress. You must also be sure that the FeatureSource has been opened. 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.
+  * //This method is used to start a transaction, assuming that the FeatureSource allows editing. There are some additional prerequisites to beginning a transaction, such as ensuring that a transaction is not already in progress. You must also be sure that the FeatureSource has been opened. 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.//
 == Return Value ==
@@ Line 96: / Line 101: @@
 ** {{wiki:PublicMethod.gif|}} AddFeature(Feature) **
-This method adds a new Feature to an existing transaction.
+  * //This method adds a new Feature to an existing transaction.//
 == Remarks ==
-This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. 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.
+  * //This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. 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.//
 == Return Value ==
@@ Line 112: / Line 117: @@
 ** {{wiki:PublicMethod.gif|}} AddFeature(BaseShape) **
-This method adds a new Feature (composed of the passed-in BaseShape) to an existing transaction.
+  * //This method adds a new Feature (composed of the passed-in BaseShape) to an existing transaction.//
 == Remarks ==
-This method adds a new Feature (composed of the passed-in BaseShape) to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. 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.
+  * //This method adds a new Feature (composed of the passed-in BaseShape) to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. 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.//
 == Return Value ==
@@ Line 128: / Line 133: @@
 ** {{wiki:PublicMethod.gif|}} AddFeature(BaseShape,IDictionary<String,String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 148: / Line 153: @@
 ** {{wiki:PublicMethod.gif|}} DeleteFeature(String) **
-This method deletes a Feature from an existing transaction.
+  * //This method deletes a Feature from an existing transaction.//
 == Remarks ==
-This method deletes a Feature from an existing transaction. You will need to ensure that you have started a transaction by calling the BeginTransaction. 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.
+  * //This method deletes a Feature from an existing transaction. You will need to ensure that you have started a transaction by calling the BeginTransaction. 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.//
 == Return Value ==
@@ Line 164: / Line 169: @@
 ** {{wiki:PublicMethod.gif|}} UpdateFeature(Feature) **
-This method updates a Feature in an existing transaction.
+  * //This method updates a Feature in an existing transaction.//
 == Remarks ==
-This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling the BeginTransaction.The Transaction SystemThe 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.
+  * //This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling the BeginTransaction.The Transaction SystemThe 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.//
 == Return Value ==
@@ Line 180: / Line 185: @@
 ** {{wiki:PublicMethod.gif|}} UpdateFeature(BaseShape) **
-This method updates a Feature (composed of the passed-in BaseShape) in an existing transaction.
+  * //This method updates a Feature (composed of the passed-in BaseShape) in an existing transaction.//
 == Remarks ==
-This method updates a Feature (composed of the passed-in BaseShape) in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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.
+  * //This method updates a Feature (composed of the passed-in BaseShape) in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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.//
 == Return Value ==
@@ Line 196: / Line 201: @@
 ** {{wiki:PublicMethod.gif|}} UpdateFeature(BaseShape,IDictionary<String,String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 216: / Line 221: @@
 ** {{wiki:PublicMethod.gif|}} RollbackTransaction() **
-This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted.
+  * //This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted.//
 == Remarks ==
-This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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.
+  * //This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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.//
 == Return Value ==
@@ Line 228: / Line 233: @@
 ** {{wiki:PublicMethod.gif|}} CommitTransaction() **
-This method will commit the existing transaction to its underlying source of data.
+  * //This method will commit the existing transaction to its underlying source of data.//
 == Remarks ==
-This method is the concrete wrapper for the virtual method CommitTransactionCore. As this is the concrete version, the real work is done in the Core version of the method. It will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. Lastly, it will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the virtual method CommitTransactionCore. As this is the concrete version, the real work is done in the Core version of the method. It will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. Lastly, it will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe 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. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 240: / Line 245: @@
 ** {{wiki:PublicMethod.gif|}} AddColumn(FeatureSourceColumn) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 256: / Line 261: @@
 ** {{wiki:PublicMethod.gif|}} DeleteColumn(String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 272: / Line 277: @@
 ** {{wiki:PublicMethod.gif|}} UpdateColumn(String,FeatureSourceColumn) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 292: / Line 297: @@
 ** {{wiki:PublicMethod.gif|}} GetAllFeatures(IEnumerable<String>) **
-This method returns all of the InternalFeatures in the FeatureSource.
+  * //This method returns all of the InternalFeatures in the FeatureSource.//
 == Remarks ==
-This method returns all of the InternalFeatures in the FeatureSource. It will return whatever is returned by the GetAllFeaturesCore method, along with any of the additions or subtractions made if you are in a transaction and that transaction is configured to be live. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures in the FeatureSource. It will return whatever is returned by the GetAllFeaturesCore method, along with any of the additions or subtractions made if you are in a transaction and that transaction is configured to be live. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 308: / Line 313: @@
 ** {{wiki:PublicMethod.gif|}} GetAllFeatures(ReturningColumnsType) **
-This method returns all of the InternalFeatures in the FeatureSource.
+  * //This method returns all of the InternalFeatures in the FeatureSource.//
 == Remarks ==
-This method returns all of the InternalFeatures in the FeatureSource. It will return whatever is returned by the GetAllFeaturesCore method, along with any of the additions or subtractions made if you are in a transaction and that transaction is configured to be live. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures in the FeatureSource. It will return whatever is returned by the GetAllFeaturesCore method, along with any of the additions or subtractions made if you are in a transaction and that transaction is configured to be live. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 324: / Line 329: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesOutsideBoundingBox(RectangleShape,IEnumerable<String>) **
-This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.//
 == 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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 344: / Line 349: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesOutsideBoundingBox(RectangleShape,ReturningColumnsType) **
-This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.//
 == 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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 364: / Line 369: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesInsideBoundingBox(RectangleShape,IEnumerable<String>) **
-This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 380: / Line 385: @@
     * Type:IEnumerable<String>
     * Description:This parameter allows you to select the field names of the column data you wish to return with each Feature.
+<div newline></div>
+** {{wiki:PublicMethod.gif|}} GetFeaturesInsideBoundingBox(RectangleShape,IEnumerable<String>,IEnumerable<String>) **
+  * //N/A//
+== Remarks ==
+  * //N/A//
+== Return Value ==
+  * Type:Collection<[[ThinkGeo.MapSuite.Core.Feature|Feature]]>
+  * Description:N/A
+== Parameters ==
+  * //boundingBox//
+    * Type:[[ThinkGeo.MapSuite.Core.RectangleShape|RectangleShape]]
+    * Description:N/A
+  * //returningColumnNames//
+    * Type:IEnumerable<String>
+    * Description:N/A
+  * //filters//
+    * Type:IEnumerable<String>
+    * Description:N/A
 <div newline></div>
 ** {{wiki:PublicMethod.gif|}} GetFeaturesInsideBoundingBox(RectangleShape,ReturningColumnsType) **
-This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we highly recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures of this FeatureSource inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we highly recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 404: / Line 433: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesForDrawing(RectangleShape,Double,Double,IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 436: / Line 465: @@
 ** {{wiki:PublicMethod.gif|}} ApplyFilters(IEnumerable<Feature>,IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 460: / Line 489: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesForDrawing(RectangleShape,Double,Double,IEnumerable<String>) **
-This method returns the InternalFeatures that will be used for drawing.
+  * //This method returns the InternalFeatures that will be used for drawing.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesForDrawing uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesForDrawing uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 488: / Line 517: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesForDrawing(RectangleShape,Double,Double,ReturningColumnsType) **
-This method returns the InternalFeatures that will be used for drawing.
+  * //This method returns the InternalFeatures that will be used for drawing.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesForDrawing uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are in a transaction and that transaction is live, this method will also take that into consideration. The default implementation of GetFeaturesForDrawing uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 516: / Line 545: @@
 ** {{wiki:PublicMethod.gif|}} SpatialQuery(BaseShape,QueryType,IEnumerable<String>) **
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.//
 == Remarks ==
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 540: / Line 569: @@
 ** {{wiki:PublicMethod.gif|}} SpatialQuery(BaseShape,QueryType,IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 568: / Line 597: @@
 ** {{wiki:PublicMethod.gif|}} SpatialQuery(BaseShape,QueryType,ReturningColumnsType) **
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.//
 == Remarks ==
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 592: / Line 621: @@
 ** {{wiki:PublicMethod.gif|}} SpatialQuery(Feature,QueryType,IEnumerable<String>) **
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.//
 == Remarks ==
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 616: / Line 645: @@
 ** {{wiki:PublicMethod.gif|}} SpatialQuery(Feature,QueryType,ReturningColumnsType) **
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.//
 == Remarks ==
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If there is a current transaction and it is marked as live, then the results will include any transaction Feature that applies.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 640: / Line 669: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(BaseShape,GeographyUnit,Int32,IEnumerable<String>) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 668: / Line 697: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(BaseShape,GeographyUnit,Int32,ReturningColumnsType) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 696: / Line 725: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(Feature,GeographyUnit,Int32,IEnumerable<String>) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 724: / Line 753: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(Feature,GeographyUnit,Int32,ReturningColumnsType) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 752: / Line 781: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(BaseShape,GeographyUnit,Int32,IEnumerable<String>,Double,DistanceUnit) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 788: / Line 817: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesNearestTo(Feature,GeographyUnit,Int32,IEnumerable<String>,Double,DistanceUnit) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 824: / Line 853: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesWithinDistanceOf(BaseShape,GeographyUnit,DistanceUnit,Double,IEnumerable<String>) **
-This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.
+  * //This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.//
 == 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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 856: / Line 885: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesWithinDistanceOf(BaseShape,GeographyUnit,DistanceUnit,Double,ReturningColumnsType) **
-This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.
+  * //This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.//
 == 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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 888: / Line 917: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesWithinDistanceOf(Feature,GeographyUnit,DistanceUnit,Double,IEnumerable<String>) **
-This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.
+  * //This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.//
 == 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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 920: / Line 949: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesWithinDistanceOf(Feature,GeographyUnit,DistanceUnit,Double,ReturningColumnsType) **
-This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.
+  * //This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.//
 == 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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 952: / Line 981: @@
 ** {{wiki:PublicMethod.gif|}} GetFeatureById(String,IEnumerable<String>) **
-This method returns a Feature by providing its Id in the FeatureSource.
+  * //This method returns a Feature by providing its Id in the FeatureSource.//
 == Remarks ==
-This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 972: / Line 1001: @@
 ** {{wiki:PublicMethod.gif|}} GetFeatureById(String,ReturningColumnsType) **
-This method returns a Feature by providing its Id in the FeatureSource.
+  * //This method returns a Feature by providing its Id in the FeatureSource.//
 == Remarks ==
-This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 992: / Line 1021: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByIds(IEnumerable<String>,IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1016: / Line 1045: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByIds(IEnumerable<String>,IEnumerable<String>) **
-This method returns a collection of InternalFeatures by providing a group of Ids.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids.//
 == Remarks ==
-This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 1036: / Line 1065: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByIds(IEnumerable<String>,ReturningColumnsType) **
-This method returns a collection of InternalFeatures by providing a group of Ids.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids.//
 == Remarks ==
-This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 1056: / Line 1085: @@
 ** {{wiki:PublicMethod.gif|}} GetBoundingBoxById(String) **
-This method returns a bounding box based on the InternalFeatures Id specified.
+  * //This method returns a bounding box based on the InternalFeatures Id specified.//
 == Remarks ==
-This method returns a bounding box by providing an Id. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a bounding box by providing an Id. The internal implementation calls the GetFeaturesByIdsCore and only passes one Id in the collection. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 1072: / Line 1101: @@
 ** {{wiki:PublicMethod.gif|}} GetBoundingBoxByIds(IEnumerable<String>) **
-This method returns a collection of bounding boxes based on the Feature Ids specified.
+  * //This method returns a collection of bounding boxes based on the Feature Ids specified.//
 == Remarks ==
-This method returns a bounding boxes by providing a goupd of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a bounding boxes by providing a goupd of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 1088: / Line 1117: @@
 ** {{wiki:PublicMethod.gif|}} GetBoundingBoxesByIds(IEnumerable<String>) **
-This method returns a collection of bounding boxes based on the Feature Ids specified.
+  * //This method returns a collection of bounding boxes based on the Feature Ids specified.//
 == Remarks ==
-This method returns a bounding boxes by providing a goupd of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a bounding boxes by providing a goupd of Ids. The internal implementation calls the GetFeaturesByIdsCore. That method in turn calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 1104: / Line 1133: @@
 ** {{wiki:PublicMethod.gif|}} GetFirstFeaturesWellKnownType() **
-This method returns the well known type that represents the first feature from FeatureSource.
+  * //This method returns the well known type that represents the first feature from FeatureSource.//
 == Remarks ==
-This method is the concrete wrapper for the virtual method GetFirstFeaturesWellKnownTypeCore. It will return whatever is returned by the GetFirstFeaturesWellKnownTypeCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetCountCore method is, please see the documentation for it. The default implementation of GetFirstFeaturesWellKnownTypeCore uses the GetAllFeaturesCore method to get WellKnownType of the first feature from all features. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the virtual method GetFirstFeaturesWellKnownTypeCore. It will return whatever is returned by the GetFirstFeaturesWellKnownTypeCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetCountCore method is, please see the documentation for it. The default implementation of GetFirstFeaturesWellKnownTypeCore uses the GetAllFeaturesCore method to get WellKnownType of the first feature from all features. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 1116: / Line 1145: @@
 ** {{wiki:PublicMethod.gif|}} CanGetBoundingBoxQuickly() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1128: / Line 1157: @@
 ** {{wiki:PublicMethod.gif|}} CanGetCountQuickly() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1140: / Line 1169: @@
 ** {{wiki:PublicMethod.gif|}} GetDistinctColumnValues(String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1156: / Line 1185: @@
 ** {{wiki:PublicMethod.gif|}} GetAllFeatures(ReturningColumnsType,Int32) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1176: / Line 1205: @@
 ** {{wiki:PublicMethod.gif|}} GetAllFeatures(ReturningColumnsType,Int32,Int32) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1200: / Line 1229: @@
 ** {{wiki:PublicMethod.gif|}} GetAllFeatures(IEnumerable<String>,Int32,Int32) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1224: / Line 1253: @@
 ** {{wiki:PublicMethod.gif|}} ExecuteNonQuery(String) **
-Executes a SQL statement against a connection object.
+  * //Executes a SQL statement against a connection object.//
 == Remarks ==
-You can use ExecuteNonQuery to perform catalog operations (for example, querying the structure of a database or creating database objects such as tables), or to change the data in a database by executing UPDATE, INSERT, or DELETE statements. Although ExecuteNonQuery does not return any rows, any output parameters or return values mapped to parameters are populated with data. For UPDATE, INSERT, and DELETE statements, the return value is the number of rows affected by the command.
+  * //You can use ExecuteNonQuery to perform catalog operations (for example, querying the structure of a database or creating database objects such as tables), or to change the data in a database by executing UPDATE, INSERT, or DELETE statements. Although ExecuteNonQuery does not return any rows, any output parameters or return values mapped to parameters are populated with data. For UPDATE, INSERT, and DELETE statements, the return value is the number of rows affected by the command.//
 == Return Value ==
@@ Line 1240: / Line 1269: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByColumnValue(String,String,ReturningColumnsType) **
-Get all of the features by passing a columnName and a specified columValue.
+  * //Get all of the features by passing a columnName and a specified columValue.//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1264: / Line 1293: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByColumnValue(String,String,IEnumerable<String>) **
-Get all of the features by passing a columnName and a specified columValue.
+  * //Get all of the features by passing a columnName and a specified columValue.//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1288: / Line 1317: @@
 ** {{wiki:PublicMethod.gif|}} GetFeaturesByColumnValue(String,String) **
-Get all of the features by passing a columnName and a specified columValue.
+  * //Get all of the features by passing a columnName and a specified columValue.//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1308: / Line 1337: @@
 ** {{wiki:PublicMethod.gif|}} ExecuteScalar(String) **
-Executes the query and returns the first column of the first row in the result set returned by the query. All other columns and rows are ignored.
+  * //Executes the query and returns the first column of the first row in the result set returned by the query. All other columns and rows are ignored.//
 == Remarks ==
-Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.
+  * //Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.//
 == Return Value ==
@@ Line 1324: / Line 1353: @@
 ** {{wiki:PublicMethod.gif|}} ExecuteQuery(String) **
-Executes the query and returns the result returned by the query.
+  * //Executes the query and returns the result returned by the query.//
 == Remarks ==
-Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.
+  * //Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.//
 == Return Value ==
@@ Line 1340: / Line 1369: @@
 ** {{wiki:PublicMethod.gif|}} GetColumns() **
-This method returns the columns available for the FeatureSource and caches them.
+  * //This method returns the columns available for the FeatureSource and caches them.//
 == Remarks ==
-As this is the concrete method wrapping the GetColumnsCore, it is important to note that this method will cache the results to GetColumnsCore. What this means is that the first time this method is called it will call GetCollumnsCore, which is protected, and cache the results. The next time this method is called it will not call GetColumnsCore again. This was done to increase speed, as this is a critical method that is used very often in the internal code of the class. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //As this is the concrete method wrapping the GetColumnsCore, it is important to note that this method will cache the results to GetColumnsCore. What this means is that the first time this method is called it will call GetCollumnsCore, which is protected, and cache the results. The next time this method is called it will not call GetColumnsCore again. This was done to increase speed, as this is a critical method that is used very often in the internal code of the class. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 1352: / Line 1381: @@
 ** {{wiki:PublicMethod.gif|}} RefreshColumns() **
-This method refresh the columns available for the FeatureSource and caches them.
+  * //This method refresh the columns available for the FeatureSource and caches them.//
 == Remarks ==
-None.
+  * //None.//
 == Return Value ==
@@ Line 1364: / Line 1393: @@
 ** {{wiki:PublicMethod.gif|}} GetCount() **
-This method returns the count of the number of records in this FeatureSource.
+  * //This method returns the count of the number of records in this FeatureSource.//
 == Remarks ==
-This method is the concrete wrapper for the virtual method GetCountCore. It will return whatever is returned by the GetCountCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetCountCore method is, please see the documentation for it. The default implementation of GetCountCore uses the GetAllRecordsCore method to calculate how many records there are in the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.
+  * //This method is the concrete wrapper for the virtual method GetCountCore. It will return whatever is returned by the GetCountCore method, along with any additions or subtractions made if you are in a transaction and that transaction is configured to be live. To determine what the default implementation of the abstract GetCountCore method is, please see the documentation for it. The default implementation of GetCountCore uses the GetAllRecordsCore method to calculate how many records there are in the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. As this is a concrete public method that wraps a Core method, we reserve the right to add events and other logic to pre- or post-process data returned by the Core version of the method. In this way, we leave our framework open on our end, but also allow you the developer to extend our logic to suit your needs. If you have questions about this, please contact our support team as we would be happy to work with you on extending our framework.//
 == Return Value ==
@@ Line 1376: / Line 1405: @@
 ** {{wiki:PublicMethod.gif|}} ToString() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1388: / Line 1417: @@
 ** {{wiki:PublicMethod.gif|}} Equals(Object) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1404: / Line 1433: @@
 ** {{wiki:PublicMethod.gif|}} GetHashCode() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1416: / Line 1445: @@
 ** {{wiki:PublicMethod.gif|}} GetType() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1427: / Line 1456: @@
 <div newline></div>
 ==== Protected Methods ====
+** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(BaseShape) **
+  * //This method de-projects items based on the Projection of the FeatureSource.//
+== Remarks ==
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
+== Return Value ==
+  * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
+  * Description:This method de-projects a BaseShape based on the Projection of the FeatureSource.
+== Parameters ==
+  * //baseShape//
+    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
+    * Description:This parameter represents the BaseShape you wish to de-project.
+<div newline></div>
 ** {{wiki:ProtectedMethod.gif|}} ConvertToExternalProjection(IEnumerable<Feature>) **
-This method projects items based on the Projection of the FeatureSource.
+  * //This method projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 1445: / Line 1490: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(IEnumerable<Feature>) **
-This method de-projects items based on the Projection of the FeatureSource.
+  * //This method de-projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 1461: / Line 1506: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToExternalProjection(Feature) **
-This method projects items based on the Projection of the FeatureSource.
+  * //This method projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 1477: / Line 1522: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(Feature) **
-This method de-projects items based on the Projection of the FeatureSource.
+  * //This method de-projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 1493: / Line 1538: @@
 ** {{wiki:ProtectedMethod.gif|}} GetColumnNamesInsideFeatureSource(IEnumerable<String>) **
-This method returns the field names that are in the FeatureSource from a list of provided field names.
+  * //This method returns the field names that are in the FeatureSource from a list of provided field names.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that, as a general rule, returning column data of a Feature or a set of InternalFeatures happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. Let's say, for example, that you want to add a new Find method called FindLargeFeatures. You pass in a group of columns to return. Most of the time, the requested columns will actually be in the FeatureSource, but sometimes they will not. The way we allow users to get data from outside of the Feature Source is by raising an event called CustomColumnFetch. This way, we allow people to provide data that is outside of the FeatureSource. Since you will be implementing your own public method, you will want to support this as all of our other public methods do. When you first enter the public method, you will want to separate out the fields that are in the FeatureSource from those that are not. You can call this method and the GetColumnNamesOutsideFeatureSource. If inside your public method you need to call any of our Core methods, then you need to make sure that you only pass in the list of column names that are in the FeatureSource. We assume that Core methods are simple and they do not handle this complexity. With the list of non-FeatureSource column names, you simply loop through each column name for each record and call the OnCustomColumnFetch method while passing in the proper parameters. This will allow you give the user a chance to provide the values for the Feature's fields that were not in the FeatureSource. After that, you combine your results and pass them back out as the return. public Collection<Feature> FindLargeFeatures(double AreaSize, IEnumerable <string> columnsToReturn) {Step 1: Separate the columns that are in the FeatureSource from those that are not.  Step 2: Call any Core Methods and only pass in the columns that are in the FeatureSourceStep3: For Each feature/column name combination, call the OnCustomFiedlFetch and allow your user to provide the custom data.  Step4: Integrate the custom data with the result of the Core method plus any processing you did. Then return the consolidated result. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that, as a general rule, returning column data of a Feature or a set of InternalFeatures happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. Let's say, for example, that you want to add a new Find method called FindLargeFeatures. You pass in a group of columns to return. Most of the time, the requested columns will actually be in the FeatureSource, but sometimes they will not. The way we allow users to get data from outside of the Feature Source is by raising an event called CustomColumnFetch. This way, we allow people to provide data that is outside of the FeatureSource. Since you will be implementing your own public method, you will want to support this as all of our other public methods do. When you first enter the public method, you will want to separate out the fields that are in the FeatureSource from those that are not. You can call this method and the GetColumnNamesOutsideFeatureSource. If inside your public method you need to call any of our Core methods, then you need to make sure that you only pass in the list of column names that are in the FeatureSource. We assume that Core methods are simple and they do not handle this complexity. With the list of non-FeatureSource column names, you simply loop through each column name for each record and call the OnCustomColumnFetch method while passing in the proper parameters. This will allow you give the user a chance to provide the values for the Feature's fields that were not in the FeatureSource. After that, you combine your results and pass them back out as the return. public Collection<Feature> FindLargeFeatures(double AreaSize, IEnumerable <string> columnsToReturn) {Step 1: Separate the columns that are in the FeatureSource from those that are not.  Step 2: Call any Core Methods and only pass in the columns that are in the FeatureSourceStep3: For Each feature/column name combination, call the OnCustomFiedlFetch and allow your user to provide the custom data.  Step4: Integrate the custom data with the result of the Core method plus any processing you did. Then return the consolidated result. }//
 == Return Value ==
@@ Line 1509: / Line 1554: @@
 ** {{wiki:ProtectedMethod.gif|}} GetColumnNamesOutsideFeatureSource(IEnumerable<String>) **
-This method returns the field names that are not in the FeatureSource from a list of provided field names.
+  * //This method returns the field names that are not in the FeatureSource from a list of provided field names.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that, as a general rule, returning column data of a Feature or a set of InternalFeatures happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. Let's say, for example, that you want to add a new Find method called FindLargeFeatures. You pass in a group of columns to return. Most of the time, the requested columns will actually be in the FeatureSource, but sometimes they will not. The way we allow users to get data from outside of the Feature Source is by raising an event called CustomColumnFetch. This way, we allow people to provide data that is outside of the FeatureSource. Since you will be implementing your own public method, you will want to support this as all of our other public methods do. When you first enter the public method, you will want to separate out the fields that are in the FeatureSource from those that are not. You can call this method and the GetColumnNamesOutsideFeatureSource. If inside your public method you need to call any of our Core methods, then you need to make sure that you only pass in the list of column names that are in the FeatureSource. We assume that Core methods are simple and they do not handle this complexity. With the list of non-FeatureSource column names, you simply loop through each column name for each record and call the OnCustomColumnFetch method while passing in the proper parameters. This will allow you give the user a chance to provide the values for the Feature's fields that were not in the FeatureSource. After that, you combine your results and pass them back out as the return. public Collection<Feature> FindLargeFeatures(double AreaSize, IEnumerable <string> columnsToReturn) {Step 1: Separate the columns that are in the FeatureSource from those that are not.  Step 2: Call any Core Methods and only pass in the columns that are in the FeatureSourceStep3: For Each feature/column name combination, call the OnCustomFiedlFetch and allow your user to provide the custom data.  Step4: Integrate the custom data with the result of the Core method plus any processing you did. Then return the consolidated result. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that, as a general rule, returning column data of a Feature or a set of InternalFeatures happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. Let's say, for example, that you want to add a new Find method called FindLargeFeatures. You pass in a group of columns to return. Most of the time, the requested columns will actually be in the FeatureSource, but sometimes they will not. The way we allow users to get data from outside of the Feature Source is by raising an event called CustomColumnFetch. This way, we allow people to provide data that is outside of the FeatureSource. Since you will be implementing your own public method, you will want to support this as all of our other public methods do. When you first enter the public method, you will want to separate out the fields that are in the FeatureSource from those that are not. You can call this method and the GetColumnNamesOutsideFeatureSource. If inside your public method you need to call any of our Core methods, then you need to make sure that you only pass in the list of column names that are in the FeatureSource. We assume that Core methods are simple and they do not handle this complexity. With the list of non-FeatureSource column names, you simply loop through each column name for each record and call the OnCustomColumnFetch method while passing in the proper parameters. This will allow you give the user a chance to provide the values for the Feature's fields that were not in the FeatureSource. After that, you combine your results and pass them back out as the return. public Collection<Feature> FindLargeFeatures(double AreaSize, IEnumerable <string> columnsToReturn) {Step 1: Separate the columns that are in the FeatureSource from those that are not.  Step 2: Call any Core Methods and only pass in the columns that are in the FeatureSourceStep3: For Each feature/column name combination, call the OnCustomFiedlFetch and allow your user to provide the custom data.  Step4: Integrate the custom data with the result of the Core method plus any processing you did. Then return the consolidated result. }//
 == Return Value ==
@@ Line 1525: / Line 1570: @@
 ** {{wiki:ProtectedMethod.gif|}} GetReturningColumnNames(ReturningColumnsType) **
-Get returning columnNames according to the returningColumnType.
+  * //Get returning columnNames according to the returningColumnType.//
 == Remarks ==
-The concreted FeatureSource can override this logic if needed.
+  * //The concreted FeatureSource can override this logic if needed.//
 == Return Value ==
@@ Line 1539: / Line 1584: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} cRQ=(Collection<Feature>) **
+** {{wiki:ProtectedMethod.gif|}} RemoveEmptyAndExcludeFeatures(Collection<Feature>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1557: / Line 1602: @@
 ** {{wiki:ProtectedMethod.gif|}} OnDrawingProgressChanged(DrawingProgressChangedEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1571: / Line 1616: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} dRQ=(IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} GetColumnNamesOutsideFeatureSourceCall(IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1587: / Line 1632: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} dxQ=(IEnumerable<String>,IEnumerable<String>,ZoomLevel,Func<Collection<Feature>>,IEnumerable<String>,RectangleShape) **
+** {{wiki:ProtectedMethod.gif|}} GetFeaturesByActionWithStyleFilters(IEnumerable<String>,IEnumerable<String>,ZoomLevel,Func<Collection<Feature>>,IEnumerable<String>,RectangleShape) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1623: / Line 1668: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} eBQ=(IEnumerable<String>,Func<IEnumerable<String>,Collection<Feature>>,IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} ApplyLinkColumnValues(IEnumerable<String>,Func<IEnumerable<String>,Collection<Feature>>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1647: / Line 1692: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} eBQ=(IEnumerable<Feature>,IEnumerable<String>,IEnumerable<String>,IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} ApplyLinkColumnValues(IEnumerable<Feature>,IEnumerable<String>,IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1675: / Line 1720: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} eRQ=(IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} GetRequiredColumnNamesForLink(IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1691: / Line 1736: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} ehQ=(IEnumerable<String>,IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} GetReturningColumnNamesForLink(IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1711: / Line 1756: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} exQ=() **
+** {{wiki:ProtectedMethod.gif|}} GetFlatLinkSources() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1723: / Line 1768: @@
 == Parameters ==
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} fxQ=(String) **
+** {{wiki:ProtectedMethod.gif|}} CheckIsLinkColumn(String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1739: / Line 1784: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} gBQ=(IEnumerable<String>,IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}} CheckHasLinkColumns(IEnumerable<String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1761: / Line 1806: @@
 ** {{wiki:ProtectedMethod.gif|}} GetBoundingBoxCore() **
-This method returns the bounding box which encompasses all of the features in the FeatureSource.
+  * //This method returns the bounding box which encompasses all of the features in the FeatureSource.//
 == Remarks ==
-This protected virtual method is called from the concrete public method GetBoundingBox. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetBoundingBox. In this way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetBoundingBoxCore uses the GetAllRecordsCore method to calculate the bounding box of the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the BoundingBox by calling the GetAllFeatureCore method and deriving it from each feature. This is a very inefficient way to get the BoundingBox in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the BoundingBox is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the BoundingBox of all the records without returning them. In these ways you can greatly improve the performance of this method.
+  * //This protected virtual method is called from the concrete public method GetBoundingBox. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetBoundingBox. In this way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetBoundingBoxCore uses the GetAllRecordsCore method to calculate the bounding box of the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the BoundingBox by calling the GetAllFeatureCore method and deriving it from each feature. This is a very inefficient way to get the BoundingBox in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the BoundingBox is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the BoundingBox of all the records without returning them. In these ways you can greatly improve the performance of this method.//
 == Return Value ==
@@ Line 1773: / Line 1818: @@
 ** {{wiki:ProtectedMethod.gif|}} CloneDeepCore() **
-Create a copy of a FeatureSource using the deep clone process. The default implementation uses serialization.
+  * //Create a copy of a FeatureSource using the deep clone process. The default implementation uses serialization.//
 == Remarks ==
-The difference between deep clone and shallow clone is as follows: In shallow cloning, only the object is copied; the objects within it are not. By contrast, deep cloning copies the cloned object as well as all the objects within.
+  * //The difference between deep clone and shallow clone is as follows: In shallow cloning, only the object is copied; the objects within it are not. By contrast, deep cloning copies the cloned object as well as all the objects within.//
 == Return Value ==
@@ Line 1785: / Line 1830: @@
 ** {{wiki:ProtectedMethod.gif|}} OpenCore() **
-This method opens the FeatureSource so that it is initialized and ready to use.
+  * //This method opens the FeatureSource so that it is initialized and ready to use.//
 == Remarks ==
-This protected virtual method is called from the concrete public method Open. The Open method plays an important role, as it is responsible for initializing the FeatureSource. Most methods on the FeatureSource will throw an exception if the state of the FeatureSource is not opened. When the map draws each layer, it will open the FeatureSource as one of its first steps, then after it is finished drawing with that layer it will close it. In this way we are sure to release all resources used by the FeatureSource. When implementing this virtual method ,consider opening files for file-based sources, connecting to databases in the database-based sources and so on. You will get a chance to close these in the Close method of the FeatureSource.
+  * //This protected virtual method is called from the concrete public method Open. The Open method plays an important role, as it is responsible for initializing the FeatureSource. Most methods on the FeatureSource will throw an exception if the state of the FeatureSource is not opened. When the map draws each layer, it will open the FeatureSource as one of its first steps, then after it is finished drawing with that layer it will close it. In this way we are sure to release all resources used by the FeatureSource. When implementing this virtual method ,consider opening files for file-based sources, connecting to databases in the database-based sources and so on. You will get a chance to close these in the Close method of the FeatureSource.//
 == Return Value ==
@@ Line 1797: / Line 1842: @@
 ** {{wiki:ProtectedMethod.gif|}} CloseCore() **
-This method closes the FeatureSource and releases any resources it was using.
+  * //This method closes the FeatureSource and releases any resources it was using.//
 == Remarks ==
-This protected virtual method is called from the concrete public method Close. The close method plays an important role in the life cycle of the FeatureSource. It may be called after drawing to release any memory and other resources that were allocated since the Open method was called. If you override this method, it is recommended that you take the following things into account: This method may be called multiple times, so we suggest you write the method so that that a call to a closed FeatureSource is ignored and does not generate an error. We also suggest that in the Close you free all resources that have been opened. Remember that the object will not be destroyed, but will be re-opened possibly in the near future.
+  * //This protected virtual method is called from the concrete public method Close. The close method plays an important role in the life cycle of the FeatureSource. It may be called after drawing to release any memory and other resources that were allocated since the Open method was called. If you override this method, it is recommended that you take the following things into account: This method may be called multiple times, so we suggest you write the method so that that a call to a closed FeatureSource is ignored and does not generate an error. We also suggest that in the Close you free all resources that have been opened. Remember that the object will not be destroyed, but will be re-opened possibly in the near future.//
 == Return Value ==
@@ Line 1809: / Line 1854: @@
 ** {{wiki:ProtectedMethod.gif|}} CommitTransactionCore(TransactionBuffer) **
-This method will commit the existing transaction to its underlying source of data.
+  * //This method will commit the existing transaction to its underlying source of data.//
 == Remarks ==
-This method will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. If you are implementing your own FeatureSource, this is one of the crucial methods you must create. It should be fairly straightforward that you will loop through the transaction buffer and add, edit or delete the InternalFeatures in your underlying data source. Remember to build and pass back the TransactionResult class so that users of your FeatureSource can respond to failures you may encounter while committing the InternalFeatures. We will handle the end of the transaction and also the cleanup of the transaction buffer. Your task will be to commit the records and produce a TransactionResult return.The Transaction SystemThe 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.
+  * //This method will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. If you are implementing your own FeatureSource, this is one of the crucial methods you must create. It should be fairly straightforward that you will loop through the transaction buffer and add, edit or delete the InternalFeatures in your underlying data source. Remember to build and pass back the TransactionResult class so that users of your FeatureSource can respond to failures you may encounter while committing the InternalFeatures. We will handle the end of the transaction and also the cleanup of the transaction buffer. Your task will be to commit the records and produce a TransactionResult return.The Transaction SystemThe 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.//
 == Return Value ==
@@ Line 1823: / Line 1868: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} WhQ=(Collection<Feature>,Collection<String>,Boolean) **
+** {{wiki:ProtectedMethod.gif|}} RaiseCustomColumnFetchEvent(Collection<Feature>,Collection<String>,Boolean) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1849: / Line 1894: @@
 ** {{wiki:ProtectedMethod.gif|}} GetAllFeaturesCore(IEnumerable<String>) **
-This method returns all of the InternalFeatures in the FeatureSource.
+  * //This method returns all of the InternalFeatures in the FeatureSource.//
 == Remarks ==
-This method returns all of the InternalFeatures in the FeatureSource. You will not need to consider anything about pending transactions, as this will be handled in the non-Core version of the method. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses.
+  * //This method returns all of the InternalFeatures in the FeatureSource. You will not need to consider anything about pending transactions, as this will be handled in the non-Core version of the method. The main purpose of this method is to be the anchor of all of our default virtual implementations within this class. We as the framework developers wanted to provide you the user with as much default virtual implementation as possible. To do this, we needed a way to get access to all of the features. For example, let's say we want to create a default implementation for finding all of the InternalFeatures in a bounding box. Because this is an abstract class, we do not know the specifics of the underlying data or how its spatial indexes work. What we do know is that if we get all of the records, then we can brute-force the answer. In this way, if you inherited from this class and only implemented this one method, we can provide default implementations for virtually every other API. While this is nice for you the developer if you decide to create your own FeatureSource, it comes with a price: namely, it is very inefficient. In the example we just discussed (about finding all of the InternalFeatures in a bounding box), we would not want to look at every record to fulfil this method. Instead, we would want to override the GetFeaturesInsideBoundingBoxCore and implement specific code that would be faster. For example, in Oracle Spatial there is a specific SQL statement to perform this operation very quickly. The same holds true with other specific FeatureSource examples. Most default implementations in the FeatureSource call the GetFeaturesInsideBoundingBoxCore, which by default calls the GetAllFeaturesCore. It is our advice that if you create your own FeatureSource that you ALWAYS override the GetFeatureInsideBoundingBox. This will ensure that nearly every other API will operate efficiently. Please see the specific API to determine what method it uses.//
 == Return Value ==
@@ Line 1865: / Line 1910: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesOutsideBoundingBoxCore(RectangleShape,IEnumerable<String>) **
-This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource outside of the specified bounding box.//
 == 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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient.
+  * //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, this method will also take that into consideration. The default implementation of GetFeaturesOutsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are outside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient.//
 == Return Value ==
@@ Line 1885: / Line 1930: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesInsideBoundingBoxCore(RectangleShape,IEnumerable<String>) **
-This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box.
+  * //This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are overriding this method you will not need to consider anything about transactions, as this is handled by the concrete version of this method. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we highly recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are overriding this method you will not need to consider anything about transactions, as this is handled by the concrete version of this method. The default implementation of GetFeaturesInsideBoundingBoxCore uses the GetAllRecordsCore method to determine which InternalFeatures are inside of the bounding box. We strongly recommend that you provide your own implementation for this method that will be more efficient. That is especially important for this method, as many other default virtual methods use this for their calculations. When you override this method, we highly recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 1905: / Line 1950: @@
 ** {{wiki:ProtectedMethod.gif|}} OnApplyingFilters(ApplyingFiltersFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1921: / Line 1966: @@
 ** {{wiki:ProtectedMethod.gif|}} OnAppliedFilters(AppliedFiltersFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1937: / Line 1982: @@
 ** {{wiki:ProtectedMethod.gif|}} ApplyFiltersCore(IEnumerable<Feature>,IEnumerable<String>,String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1959: / Line 2004: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} XBQ=(Collection<Feature>) **
+** {{wiki:ProtectedMethod.gif|}} ConvertToExternalProjectionIfNecessary(Collection<Feature>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1975: / Line 2020: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} XRQ=(RectangleShape,Collection<Feature>,Boolean) **
+** {{wiki:ProtectedMethod.gif|}} ProcessTransaction(RectangleShape,Collection<Feature>,Boolean) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 1999: / Line 2044: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} XhQ=(RectangleShape,Double,Double,IEnumerable<String>,RectangleShape) **
+** {{wiki:ProtectedMethod.gif|}} GetWrappingFeaturesLeft(RectangleShape,Double,Double,IEnumerable<String>,RectangleShape) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2031: / Line 2076: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} XxQ=(RectangleShape,Double,Double,IEnumerable<String>,RectangleShape) **
+** {{wiki:ProtectedMethod.gif|}} GetWrappingFeaturesRight(RectangleShape,Double,Double,IEnumerable<String>,RectangleShape) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2065: / Line 2110: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesForDrawingCore(RectangleShape,Double,Double,IEnumerable<String>) **
-This method returns the InternalFeatures that will be used for drawing.
+  * //This method returns the InternalFeatures that will be used for drawing.//
 == Remarks ==
-This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are overriding this method you will not need to consider anything about transactions, as this is handled by the concrete version of this method. The default implementation of GetFeaturesForDrawingCore uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead.
+  * //This method returns all of the InternalFeatures of this FeatureSource that are inside of the specified bounding box. If you are overriding this method you will not need to consider anything about transactions, as this is handled by the concrete version of this method. The default implementation of GetFeaturesForDrawingCore uses the GetFeaturesInsodeBoundingBoxCore with some optimizations based on the screen width and height. For example, we can determine if a feature is going to draw in only one to four pixels and in that case we may not draw the entire feature but just a subset of it instead.//
 == Return Value ==
@@ Line 2093: / Line 2138: @@
 ** {{wiki:ProtectedMethod.gif|}} SpatialQueryCore(BaseShape,QueryType,IEnumerable<String>) **
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified.//
 == Remarks ==
-This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If you override this method, you do not need to consider transactions. It is suggested that if you are looking to speed up this method that you first override the GetFeaturesInsideBoundingBoxCore and then re-test this method, as it relies heavily on that method internally. See more information below.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //This method returns all of the InternalFeatures based on the target Feature and the spatial query type specified below. If you override this method, you do not need to consider transactions. It is suggested that if you are looking to speed up this method that you first override the GetFeaturesInsideBoundingBoxCore and then re-test this method, as it relies heavily on that method internally. See more information below.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. When you override this method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 2117: / Line 2162: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesNearestToCore(BaseShape,GeographyUnit,Int32,IEnumerable<String>) **
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape.//
 == Remarks ==
-This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //This method returns a user defined number of InternalFeatures that are closest to the TargetShape. It is important to note that the TargetShape and the FeatureSource must 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 creates a small bounding box around the TargetShape and then queries the features inside of it. If we reach the number of items to find, then we measure the returned InternalFeatures to find the nearest. If we do not find enough records, we scale up the bounding box and try again. As you can see, this is not the most efficient method. If your 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 GetFeaturesNearestCore uses the GetFeaturesInsideBoundingBoxCore method for speed. We strongly recommend that you provide your own implementation for this method that will be more efficient. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 2145: / Line 2190: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesWithinDistanceOfCore(BaseShape,GeographyUnit,DistanceUnit,Double,IEnumerable<String>) **
-This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.
+  * //This method returns a collection of InternalFeatures that are within a certain distance of the TargetShape.//
 == 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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.
+  * //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 must 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 creates a bounding box around the TargetShape using the distance supplied and then queries the features inside of it. This may not be the most efficient method for this operation. If your 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. When you override GetFeaturesInsideBoundingBoxCore method, we recommend that you use any spatial indexes you have at your disposal to make this method as fast as possible.//
 == Return Value ==
@@ Line 2177: / Line 2222: @@
 ** {{wiki:ProtectedMethod.gif|}} GetBoundingBoxByIdCore(String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2193: / Line 2238: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFirstFeaturesWellKnownTypeCore() **
-This method returns the well known type that represents the first feature from FeatureSource.
+  * //This method returns the well known type that represents the first feature from FeatureSource.//
 == Remarks ==
-This protected virtual method is called from the concrete public method GetFirstFeaturesWellKnownType. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetFirstFeaturesWellKnownType. This way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetCountCore uses the GetAllRFeaturesCore method to get WellKnownType of the first feature from all features. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the count by calling the GetAllFeaturesCore method and get WellKnownType of the first feature from all features. This is a very inefficient way to get the count in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the record count is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the count of all of the records without returning them. In these ways you can greatly improve the performance of this method.
+  * //This protected virtual method is called from the concrete public method GetFirstFeaturesWellKnownType. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetFirstFeaturesWellKnownType. This way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetCountCore uses the GetAllRFeaturesCore method to get WellKnownType of the first feature from all features. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the count by calling the GetAllFeaturesCore method and get WellKnownType of the first feature from all features. This is a very inefficient way to get the count in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the record count is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the count of all of the records without returning them. In these ways you can greatly improve the performance of this method.//
 == Return Value ==
@@ Line 2205: / Line 2250: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesByIdsCore(IEnumerable<String>,IEnumerable<String>) **
-This method returns a collection of InternalFeatures by providing a group of Ids.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids.//
 == Remarks ==
-This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.
+  * //This method returns a collection of InternalFeatures by providing a group of Ids. The internal implementation calls the GetAllFeaturesCore. Because of this, if you want a more efficient version of this method, then we highly suggest you override the GetFeaturesByIdsCore method and provide a fast way to find a group of InternalFeatures by their Id.//
 == Return Value ==
@@ Line 2225: / Line 2270: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToExternalProjection(IEnumerable<RectangleShape>) **
-This method projects items based on the Projection of the FeatureSource.
+  * //This method projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 2241: / Line 2286: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(IEnumerable<RectangleShape>) **
-This method de-projects items based on the Projection of the FeatureSource.
+  * //This method de-projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 2257: / Line 2302: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToExternalProjection(RectangleShape) **
-This method projects items based on the Projection of the FeatureSource.
+  * //This method projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 2273: / Line 2318: @@
 ** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(RectangleShape) **
-This method de-projects items based on the Projection of the FeatureSource.
+  * //This method de-projects items based on the Projection of the FeatureSource.//
 == Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
+  * //This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }//
 == Return Value ==
@@ Line 2287: / Line 2332: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}} ahQ=(RectangleShape) **
+** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjectionCall(RectangleShape) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2301: / Line 2346: @@
     * Type:[[ThinkGeo.MapSuite.Core.RectangleShape|RectangleShape]]
     * Description:N/A
-<div newline></div>
-** {{wiki:ProtectedMethod.gif|}} ConvertToInternalProjection(BaseShape) **
-This method de-projects items based on the Projection of the FeatureSource.
-== Remarks ==
-This is a protected method that is intended to help developers who want to implement or extend one of our FeatureSources. It is important to note that projection, as a general rule, happens inside the non-Core methods and we usually take care of it. However, as a developer, if you wish to add a new public method, then you will need to handle the projection yourself. With these projection methods it is very easy to handle the projection and de-projection. Remember that when adding your own public methods you always de-project incoming shapes and alway project outgoing shapes. Also remember that the Core methods do not consider projection, and they assume the data being passed into them and out of them is the same unit as the underlying data. Example of a New Public Method: public Feature ProcessFeature(Feature incomingFeature) { Be sure that you use the FromProjection on the incomingFeatureParameter as the first thing you do in this method. Call a Core Method or do your own processing Be sure that you call the ToProjection on the return result of the method before you pass it out. }
-== Return Value ==
-  * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
-  * Description:This method de-projects a BaseShape based on the Projection of the FeatureSource.
-== Parameters ==
-  * //baseShape//
-    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
-    * Description:This parameter represents the BaseShape you wish to de-project.
 <div newline></div>
 ** {{wiki:ProtectedMethod.gif|}} CanGetBoundingBoxQuicklyCore() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2333: / Line 2362: @@
 ** {{wiki:ProtectedMethod.gif|}} CanGetCountQuicklyCore() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2345: / Line 2374: @@
 ** {{wiki:ProtectedMethod.gif|}} GetDistinctColumnValuesCore(String) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2361: / Line 2390: @@
 ** {{wiki:ProtectedMethod.gif|}} GetAllFeaturesCore(IEnumerable<String>,Int32,Int32) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2385: / Line 2414: @@
 ** {{wiki:ProtectedMethod.gif|}} OnGettingFeaturesByIds(GettingFeaturesByIdsFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2401: / Line 2430: @@
 ** {{wiki:ProtectedMethod.gif|}} OnGettingFeaturesForDrawing(GettingFeaturesForDrawingFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2417: / Line 2446: @@
 ** {{wiki:ProtectedMethod.gif|}} OnGettingColumns(GettingColumnsFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2433: / Line 2462: @@
 ** {{wiki:ProtectedMethod.gif|}} OnGottenColumns(GottenColumnsFeatureSourceEventArgs) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2449: / Line 2478: @@
 ** {{wiki:ProtectedMethod.gif|}} OnCustomColumnFetch(CustomColumnFetchEventArgs) **
-This method allows you to raise the CustomColumnFetch event from a derived class.
+  * //This method allows you to raise the CustomColumnFetch event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the CustomColumnFetch event. This may be useful if you plan to extend the FeatureSource and you need access to user-definable field data. Details on the event: This event is raised when fields are requested in a feature source method that do not exist in the feature source. It allows you supplement the data from any outside source you may 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.
+  * //You can call this method from a derived class to enable it to raise the CustomColumnFetch event. This may be useful if you plan to extend the FeatureSource and you need access to user-definable field data. Details on the event: This event is raised when fields are requested in a feature source method that do not exist in the feature source. It allows you supplement the data from any outside source you may 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.//
 == Return Value ==
@@ Line 2465: / Line 2494: @@
 ** {{wiki:ProtectedMethod.gif|}} OnCommittingTransaction(CommittingTransactionEventArgs) **
-This method allows you to raise the CommittingTransaction event from a derived class.
+  * //This method allows you to raise the CommittingTransaction event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the CommittingTransaction event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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 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.
+  * //You can call this method from a derived class to enable it to raise the CommittingTransaction event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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 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.//
 == Return Value ==
@@ Line 2481: / Line 2510: @@
 ** {{wiki:ProtectedMethod.gif|}} OnCommittedTransaction(CommittedTransactionEventArgs) **
-This method allows you to raise the CommittedTransaction event from a derived class.
+  * //This method allows you to raise the CommittedTransaction event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the CommittedTransaction event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: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 analyze the results of the transaction and do any cleanup code necessary. In the event some of the records did not commit, you can handle these 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.
+  * //You can call this method from a derived class to enable it to raise the CommittedTransaction event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: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 analyze the results of the transaction and do any cleanup code necessary. In the event some of the records did not commit, you can handle these 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.//
 == Return Value ==
@@ Line 2497: / Line 2526: @@
 ** {{wiki:ProtectedMethod.gif|}} OnOpeningFeatureSource(OpeningFeatureSourceEventArgs) **
-This method allows you to raise the OpeningFeatureSource event from a derived class.
+  * //This method allows you to raise the OpeningFeatureSource event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the OpeningFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.
+  * //You can call this method from a derived class to enable it to raise the OpeningFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.//
 == Return Value ==
@@ Line 2513: / Line 2542: @@
 ** {{wiki:ProtectedMethod.gif|}} OnOpenedFeatureSource(OpenedFeatureSourceEventArgs) **
-This method allows you to raise the OpenedFeatureSource event from a derived class.
+  * //This method allows you to raise the OpenedFeatureSource event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the OpenedFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.
+  * //You can call this method from a derived class to enable it to raise the OpenedFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.//
 == Return Value ==
@@ Line 2529: / Line 2558: @@
 ** {{wiki:ProtectedMethod.gif|}} OnClosingFeatureSource(ClosingFeatureSourceEventArgs) **
-This method allows you to raise the ClosingFeatureSource event from a derived class.
+  * //This method allows you to raise the ClosingFeatureSource event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the ClosingFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.
+  * //You can call this method from a derived class to enable it to raise the ClosingFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.//
 == Return Value ==
@@ Line 2545: / Line 2574: @@
 ** {{wiki:ProtectedMethod.gif|}} OnClosedFeatureSource(ClosedFeatureSourceEventArgs) **
-This method allows you to raise the ClosedFeatureSource event from a derived class.
+  * //This method allows you to raise the ClosedFeatureSource event from a derived class.//
 == Remarks ==
-You can call this method from a derived class to enable it to raise the ClosedFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.
+  * //You can call this method from a derived class to enable it to raise the ClosedFeatureSource event. This may be useful if you plan to extend the FeatureSource and you need access to the event. Details on the event: 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.//
 == Return Value ==
@@ Line 2561: / Line 2590: @@
 ** {{wiki:ProtectedMethod.gif|}} ExecuteNonQueryCore(String) **
-Executes a SQL statement against a connection object.
+  * //Executes a SQL statement against a connection object.//
 == Remarks ==
-You can use ExecuteNonQuery to perform catalog operations (for example, querying the structure of a database or creating database objects such as tables), or to change the data in a database by executing UPDATE, INSERT, or DELETE statements. Although ExecuteNonQuery does not return any rows, any output parameters or return values mapped to parameters are populated with data. For UPDATE, INSERT, and DELETE statements, the return value is the number of rows affected by the command.
+  * //You can use ExecuteNonQuery to perform catalog operations (for example, querying the structure of a database or creating database objects such as tables), or to change the data in a database by executing UPDATE, INSERT, or DELETE statements. Although ExecuteNonQuery does not return any rows, any output parameters or return values mapped to parameters are populated with data. For UPDATE, INSERT, and DELETE statements, the return value is the number of rows affected by the command.//
 == Return Value ==
@@ Line 2577: / Line 2606: @@
 ** {{wiki:ProtectedMethod.gif|}} GetFeaturesByColumnValueCore(String,String,IEnumerable<String>) **
-Get all of the features by passing a columnName and a specified columValue.
+  * //Get all of the features by passing a columnName and a specified columValue.//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2601: / Line 2630: @@
 ** {{wiki:ProtectedMethod.gif|}} ExecuteScalarCore(String) **
-Executes the query and returns the first column of the first row in the result set returned by the query. All other columns and rows are ignored.
+  * //Executes the query and returns the first column of the first row in the result set returned by the query. All other columns and rows are ignored.//
 == Remarks ==
-Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.
+  * //Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.//
 == Return Value ==
@@ Line 2617: / Line 2646: @@
 ** {{wiki:ProtectedMethod.gif|}} ExecuteQueryCore(String) **
-Executes the query and returns the result returned by the query.
+  * //Executes the query and returns the result returned by the query.//
 == Remarks ==
-Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.
+  * //Use the ExcuteScalar method to retrieve a single value from the database. This requires less code than using the ExcuteQuery method and then performing the operations necessary to generate the single value using the data.//
 == Return Value ==
@@ Line 2633: / Line 2662: @@
 ** {{wiki:ProtectedMethod.gif|}} GetColumnsCore() **
-This method returns the columns available for the FeatureSource.
+  * //This method returns the columns available for the FeatureSource.//
 == Remarks ==
-As this is the virtual core version of the Columns method, it is intended to be overridden in inherited version of the class. When overriding, you will be responsible for getting a list of all of the columns supported by the FeatureSource. In this way, the FeatureSource will know what columns are available and will remove any extra columns when making calls to other core methods. For example, if you have a FeatureSource that has three columns of information and the user calls a method that requests four columns of information (something they can do with custom fields), we will first compare what they are asking for to the results of the GetColumnsCore. This way we can strip out custom columns before calling other Core methods, which are only responsible for returning data in the FeatureSource. For more information on custom fields, please see the documentation on OnCustomFieldsFetch.
+  * //As this is the virtual core version of the Columns method, it is intended to be overridden in inherited version of the class. When overriding, you will be responsible for getting a list of all of the columns supported by the FeatureSource. In this way, the FeatureSource will know what columns are available and will remove any extra columns when making calls to other core methods. For example, if you have a FeatureSource that has three columns of information and the user calls a method that requests four columns of information (something they can do with custom fields), we will first compare what they are asking for to the results of the GetColumnsCore. This way we can strip out custom columns before calling other Core methods, which are only responsible for returning data in the FeatureSource. For more information on custom fields, please see the documentation on OnCustomFieldsFetch.//
 == Return Value ==
@@ Line 2645: / Line 2674: @@
 ** {{wiki:ProtectedMethod.gif|}} GetCountCore() **
-This method returns the count of the number of records in this FeatureSource.
+  * //This method returns the count of the number of records in this FeatureSource.//
 == Remarks ==
-This protected virtual method is called from the concrete public method GetCount. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetCount. This way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetCountCore uses the GetAllRecordsCore method to calculate how many records there are in the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the count by calling the GetAllFeatureCore method and counting each feature. This is a very inefficient way to get the count in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the record count is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the count of all of the records without returning them. In these ways you can greatly improve the performance of this method.
+  * //This protected virtual method is called from the concrete public method GetCount. It does not take into account any transaction activity, as this is the responsibility of the concrete public method GetCount. This way, as a developer, if you choose to override this method you do not have to consider transactions at all. The default implementation of GetCountCore uses the GetAllRecordsCore method to calculate how many records there are in the FeatureSource. We strongly recommend that you provide your own implementation for this method that will be more efficient. If you do not override this method, it will get the count by calling the GetAllFeatureCore method and counting each feature. This is a very inefficient way to get the count in most data sources. It is highly recommended that you override this method and replace it with a highly optimized version. For example, in a ShapeFile the record count is in the main header of the file. Similarly, if you are using Oracle Spatial, you can execute a simple query to get the count of all of the records without returning them. In these ways you can greatly improve the performance of this method.//
 == Return Value ==
@@ Line 2657: / Line 2686: @@
 ** {{wiki:ProtectedMethod.gif|}} Finalize() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2669: / Line 2698: @@
 ** {{wiki:ProtectedMethod.gif|}} MemberwiseClone() **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2681: / Line 2710: @@
 ** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} SplitColumnNames(IEnumerable<String>) **
-This method will split the column names based on our column syntax.
+  * //This method will split the column names based on our column syntax.//
 == Remarks ==
-This method is meant to be used by advanced users who are creating their own new methods on the FeatureSource. We have a system where you can concatenate column names you specify anywhere in the system to create a unique string. For example, let's say you have a dataset that has the following columns: Name, Grade and Class, and you want to create a custom label for it. Whenever you specify the column you wanted to use in the label, you could use a string like this: "[Name] received a [Grade] in [Class]" and this would be valid. Behind the scenes, this method parses the string and returns the column names separately. Then, after we have the data, there is another helper method called CombineFieldValues that will add them back together again. All of this happens normally in the concrete methods of the FeatureSource and inheriting classes; however, if you want to extend the classes and create your own concrete methods, then we suggest you use this to be compliant with the concatenation system.
+  * //This method is meant to be used by advanced users who are creating their own new methods on the FeatureSource. We have a system where you can concatenate column names you specify anywhere in the system to create a unique string. For example, let's say you have a dataset that has the following columns: Name, Grade and Class, and you want to create a custom label for it. Whenever you specify the column you wanted to use in the label, you could use a string like this: "[Name] received a [Grade] in [Class]" and this would be valid. Behind the scenes, this method parses the string and returns the column names separately. Then, after we have the data, there is another helper method called CombineFieldValues that will add them back together again. All of this happens normally in the concrete methods of the FeatureSource and inheriting classes; however, if you want to extend the classes and create your own concrete methods, then we suggest you use this to be compliant with the concatenation system.//
 == Return Value ==
@@ Line 2695: / Line 2724: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} axQ=(IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} SplitColumnNamesCall(IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2713: / Line 2742: @@
 ** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} CombineFieldValues(Dictionary<String,String>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2731: / Line 2760: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} bBQ=(Collection<Feature>,IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} ReplaceColumnValues(Collection<Feature>,IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2751: / Line 2780: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} bhQ=(IEnumerable<String>) **
+** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} HasComplicateFields(IEnumerable<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2767: / Line 2796: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} fhQ=(String,ICollection<String>) **
+** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} GetColumnNameAlias(String,ICollection<String>) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==
@@ Line 2787: / Line 2816: @@
 <div newline></div>
-** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} aRQ=(Collection<Feature>,BaseShape,GeographyUnit,Int32) **
+** {{wiki:ProtectedMethod.gif|}}{{wiki:Static.gif|}} GetFeaturesNearestFrom(Collection<Feature>,BaseShape,GeographyUnit,Int32) **
-N/A
+  * //N/A//
 == Remarks ==
-N/A
+  * //N/A//
 == Return Value ==

User Tools

Site Tools

Differences

Page Tools