Skip to content

< Back


EditTools

Namespace: ThinkGeo.Core

This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer.

public class EditTools

Inheritance ObjectEditTools

Remarks:

This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer.

Properties

IsInTransaction

This property returns true if the FeatureLayer is in a transaction and false if it is not.

public bool IsInTransaction { get; }

Property Value

Boolean

Remarks:

To enter a transaction, you must first call the BeginTransaction method of the FeatureLayer. It is possible that some FeatureLayers are read only and do not allow edits. To end a transaction, you must either call CommitTransaction or RollbackTransaction.

IsTransactionLive

This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureLayer, such as spatial queries.

public bool IsTransactionLive { get; set; }

Property Value

Boolean

Remarks:

The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.

As an example, imagine that you have a FeatureLayer 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 FeatureLayer reflect the changes.

IsEditable

This property returns whether the FeatureLayer allows edits or is read only.

public bool IsEditable { get; }

Property Value

Boolean

Remarks:

This property is useful to check if a specific FeatureLayer accepts editing. If you call BeginTransaction and this property is false, then an exception will be raised.

TransactionBuffer

This property allows you get and set the transaction buffer.

public TransactionBuffer TransactionBuffer { get; set; }

Property Value

TransactionBuffer
None

Constructors

EditTools(FeatureSource)

This is a constructor for the class.

public EditTools(FeatureSource featureSource)

Parameters

featureSource FeatureSource

        This parameter is the FeatureSource that the edit operations will pass through
        to.

Remarks:

None

Methods

BeginTransaction()

This method starts a new transaction if the FeatureLayer allows editing.

public void BeginTransaction()

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is in a transaction, it will throw an InvalidOperationException.

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which has not been opened, it will throw an InvalidOperationException.

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not editable, it will throw an InvalidOperationException.

Remarks:

This method is used to start a transaction, assuming that the FeatureLayer 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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Add(BaseShape)

This method adds a new Feature to an existing transaction.

public string Add(BaseShape shape)

Parameters

shape BaseShape

        This parameter represents the new shape that will be added to the
        transaction.

Returns

String

        This string is the ID that will uniquely identify this Feature while it is in a
        transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Add(Feature)

This method adds a new Feature to an existing transaction.

public string Add(Feature feature)

Parameters

feature Feature

        This parameter represents the new Feature that will be added to the
        transaction.

Returns

String

        This string is the ID that will uniquely identify this Feature while it is in a
        transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Add(BaseShape, Dictionary<String, String>)

This overload allows you pass in a Feature.

public string Add(BaseShape shape, Dictionary<string, string> columnValues)

Parameters

shape BaseShape

        This parameter represents the new BaseShape that will be added to the
        transaction.

columnValues Dictionary<String, String>

        This parameter represents DBF information of the new BaseShape.

Returns

String

        This string is the ID that will uniquely identify this BaseShape while it is in a
        transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

ArgumentNullException
If you pass a null as the shape, we will throw an ArgumentNullException.

ArgumentNullException
If you pass a null as the columnValues, we will throw an ArgumentNullException.

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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

ScaleUp(String, Double)

This method increases the size of the feature by the percentage given in the percentage parameter.

public void ScaleUp(string featureId, double percentage)

Parameters

featureId String
This parameter is the Id of the Feature you want to scale.

percentage Double
This is the percentage by which to increase the Feature's size.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a shape which has no points, it will throw an InvalidOperationException.

ArgumentOutOfRangeException
Passing an invalid percentage that is less than 0 will throw an ArgumentOutOfRangeException.

ArgumentOutOfRangeException
Passing an invalid percentage that is not between 0 and 100 will throw an ArgumentOutOfRangeException.

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

This method is useful when you would like to increase the size of the Feature. Note that a larger percentage will scale the shape up faster as you apply the operation multiple times. There is also a ScaleDown method that will shrink the shape as well.

ScaleDown(String, Double)

This method decreases the size of the feature by the percentage given in the percentage parameter.

public void ScaleDown(string featureId, double percentage)

Parameters

featureId String
This parameter is the Id of the Feature you want to scale.

percentage Double
This is the percentage by which to decrease the Feature's size.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a shape which has no points, it will throw an InvalidOperationException.

ArgumentOutOfRangeException
Passing an invalid percentage that is less than 0 will throw an ArgumentOutOfRangeException.

ArgumentOutOfRangeException
Passing an invalid percentage that is not between 0 and 100 will throw an ArgumentOutOfRangeException.

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

This method is useful when you would like to decrease the size of the Feature. Note that a larger percentage will scale the shape down faster as you apply the operation multiple times. There is also a ScaleUp method that will expand the shape as well.

TranslateByDegree(String, Double, Double, GeographyUnit, DistanceUnit)

This method moves the Feature from one location to another based on a distance and a direction in degrees.

public void TranslateByDegree(string featureId, double distance, double angleInDegrees, GeographyUnit shapeUnit, DistanceUnit distanceUnit)

Parameters

featureId String
This parameter is the Feature you want to move.

distance Double

        The distance is the number of units to move the shape using the angle specified.
        The distance unit will be the DistanceUnit specified in the distanceUnit parameter. The
        distance must be greater than or equal to 0.

angleInDegrees Double
A number between 0 and 360 degrees that represents the direction you wish to move the shape, with zero being up.

shapeUnit GeographyUnit

        This is the GeographicUnit of the shape you are performing the operation
        on.

distanceUnit DistanceUnit

        This is the DistanceUnit you would like to use as the measure of the translate.
        For example, if you select miles as your distanceUnit, then the distance will be
        calculated in miles.

Exceptions

ArgumentOutOfRangeException
Passing an invalid angleInDegrees that is not between 0 and 360 will throw an ArgumentOutOfRangeException.

ArgumentOutOfRangeException
If you pass in a shapeUnit that is not defined in the enumeration, it will throw a ArgumentOutOfRangeException.

ArgumentOutOfRangeException
If you pass in a distanceUnit that is not defined in the enumeration, it will throw a ArgumentOutOfRangeException.

InvalidOperationException
In the event you attempt to call this method from a shape which has no points, it will throw an InvalidOperationException.

ArgumentOutOfRangeException
Passing an invalid distance that is not greater than or equal to 0 will throw an ArgumentOutOfRangeException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

This method moves the Feature from one location to another based on angleInDegrees and the distance parameter. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with a specified distanceUnit of miles, you're going to move this shape a number of miles based on the distance and angleInDegrees. In this way, you could easily move a shape in decimal degrees five miles to the north.

If you pass a distance of 0, the operation is ignored.

TranslateByOffset(String, Double, Double, GeographyUnit, DistanceUnit)

This method moves the Feature from one location to another based on a X and Y offset distance.

public void TranslateByOffset(string featureId, double xOffset, double yOffset, GeographyUnit shapeUnit, DistanceUnit offsetUnit)

Parameters

featureId String
This parameter is the Feature you want to move.

xOffset Double

        This is the number of horizontal units of movement in the DistanceUnit specified in
        the distanceUnit parameter.

yOffset Double

        This is the number of horizontal units of movement in the DistanceUnit specified in
        the distanceUnit parameter.

shapeUnit GeographyUnit
This is the GeographicUnit of the shape you are performing the operation on.

offsetUnit DistanceUnit
This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the xOffsetDistance and yOffsetDistance will be calculated in miles.

Exceptions

ArgumentOutOfRangeException
If you pass in a distanceUnit that is not defined in the enumeration, it will throw a ArgumentOutOfRangeException.

ArgumentOutOfRangeException
If you pass in a shapeUnit that is not defined in the enumeration, it will throw a ArgumentOutOfRangeException.

InvalidOperationException
In the event you attempt to call this method from a shape that has no points, it will throw an InvalidOperationException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

This method moves the Feature from one location to another based on an X and Y offset distance. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with an X offset of 1 and a Y offset of 1, you're going to move this Feature one unit of the distanceUnit in the horizontal direction and one unit of the distanceUnit in the vertical direction. In this way, you could easily move a Feature in decimal degrees five miles on the X axis and 3 miles on the Y axis.

Rotate(String, PointShape, Single)

This method rotates the Feature any number of degrees based on a pivot point.

public void Rotate(string featureId, PointShape pivotPoint, float degreeAngle)

Parameters

featureId String
This parameter is the Feature you want to rotate.

pivotPoint PointShape
The pivotPoint represents the center of rotation.

degreeAngle Single
The number of degrees of rotation, from 0 to 360.

Exceptions

ArgumentNullException
If you pass a null as the pivotPoint, we will throw an ArgumentNullException.

ArgumentOutOfRangeException
Passing an invalid degreeAngle which is not between 0 and 360 will throw an ArgumentOutOfRangeException.

InvalidOperationException
In the event you attempt to call this method on a shape that is not valid, it will throw an InvalidOperationException.

NotImplementedException
In the event you attempt to call this method and the CanRotate property returns false, it will throw a NotImplementedException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

This method rotates the Feature based on a pivot point by a number of degrees. By placing the pivot point in the center of the Feature, you can achieve in-place rotation. By moving the pivot point outside of the center of the Feature, you can translate the shape in a circular motion. Moving the pivot point further outside of the center will make the circular area larger.

Union(String, AreaBaseShape)

This method returns the union of the Feature and the target shapes, which are defined as the set of all points in the Feature or the target shape.

public void Union(string featureId, AreaBaseShape targetShape)

Parameters

featureId String
This parameter is the Feature you want to add the new area to.

targetShape AreaBaseShape
The shape you are trying to find the union with.

Exceptions

ArgumentException
If you pass in a targetShape that does not have any points, we will throw an ArgumentException.

ArgumentNullException
If you pass a null as the targetShape, we will throw an ArgumentNullException.

InvalidOperationException
In the event you attempt to call this method on a shape that has no points, it will throw an InvalidOperationException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.


This is useful for adding area shapes together to form a larger area shape.

Union(String, Feature)

This method returns the union of the Feature and the target features, which are defined as the set of all points in the Feature or the target shape.

public void Union(string featureId, Feature targetAreaFeature)

Parameters

featureId String
This parameter is the Feature you want to add the new area to.

targetAreaFeature Feature
The feature you are trying to find the union with.

Exceptions

ArgumentNullException
If you pass a null featureId, we will throw an ArgumentNullException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.


This is useful for adding area shapes together to form a larger area shape.

GetDifference(String, AreaBaseShape)

This method returns the difference between two shapes, which are defined as the set of all points that lie in the Feature but not in the targetShape.

public void GetDifference(string featureId, AreaBaseShape targetShape)

Parameters

featureId String
This is the Feature you want to remove area from.

targetShape AreaBaseShape
The shape you are trying to find the difference with.

Exceptions

ArgumentException
If you pass in a targetShape that does not have any points, we will throw an ArgumentException.

ArgumentNullException
If you pass a null as the targetShape, we will throw an ArgumentNullException.

InvalidOperationException
In the event you attempt to call this method on a shape that has no points, it will throw an InvalidOperationException.

Remarks:

This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

GetDifference(String, Feature)

This method returns the difference between two features, which are defined as the set of all points which lie in the Feature but not in the targetFeature.

public void GetDifference(string featureId, Feature targetAreaFeature)

Parameters

featureId String
This is the Feature you want to remove area from.

targetAreaFeature Feature
The feature you are trying to find the difference with.

Delete(String)

This method deletes a Feature from an existing transaction.

public void Delete(string id)

Parameters

id String

        This string is the Id of the feature in the FeatureLayer that you wish to
        delete.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method deletes a Feature from 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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Update(BaseShape)

This method updates a Feature in an existing transaction.

public void Update(BaseShape shape)

Parameters

shape BaseShape
The shape you wish to update in the transaction. The Id of the Shape should be the feature Id which you wish to update.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method updates a Feature in 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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Update(Feature)

This method updates a Feature in an existing transaction.

public void Update(Feature feature)

Parameters

feature Feature
The Feature you wish to update in the transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method updates a Feature in 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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

Update(BaseShape, Dictionary<String, String>)

This method updates a Feature in an existing transaction.

public void Update(BaseShape shape, Dictionary<string, string> columnValues)

Parameters

shape BaseShape
The shape you wish to update in the transaction. The Id of the Shape should be the feature id which you wish to update.

columnValues Dictionary<String, String>
The column values you wish to update in the transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

Remarks:

This method updates a Feature in 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 FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

RollbackTransaction()

This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted.

public void RollbackTransaction()

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

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 System

The transaction system of a FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.

CommitTransaction()

This method will commit the existing transaction to its underlying source of data.

public TransactionResult CommitTransaction()

Returns

TransactionResult

        The returned decimalDegreesValue of this method is a TransactionResult class, which gives you the
        status of the transaction you just committed. It includes how many of the updates,
        adds, and deletes were successful and any errors that were encountered during the
        committing of the transaction.

Exceptions

InvalidOperationException
In the event you attempt to call this method on a FeatureLayer which is not in a transaction, it will throw an InvalidOperationException.

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. Finally, 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 System

The transaction system of a FeatureLayer 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 FeatureLayer. 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 FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer 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 FeatureLayer 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 FeatureLayer reflect the changes.


< Back