ArcGIS Runtime SDK for WPF - Library Reference
FeatureLayer Class
Members  Example  See Also 
ESRI.ArcGIS.Client Namespace : FeatureLayer Class

An enhanced version of the GraphicsLayer that enables displaying (and possibly editing) features from an ArcGIS Server REST service.

Object Model

FeatureLayer Class

Syntax

Visual Basic (Declaration) 
Public Class FeatureLayer 
   Inherits GraphicsLayer
   Implements IAttributionILegendSupport 
C# 
public class FeatureLayer : GraphicsLayer, IAttributionILegendSupport  

Remarks

General Comments
FeatureLayers are a special type of GraphicsLayer that allows displaying features in a map hosted by an ArcGIS Server map service (MapServer) or an ArcGIS Server feature service (FeatureServer). FeatureLayers inherit all of the functionality of a GraphicsLayer including the ability to display graphic features, which consist of geometry and attributes. Using a FeatureServer has the additional benefits of allowing client-side users to edit the features of the FeatureLayer and post them back to ArcGIS Server.

To simplify the development experience of creating an application where a client can edit the features in a FeatureLayer, consider using the the following Controls in the ESRI.ArcGIS.Client.Toolkit Assembly:

You may need to use a GeometryService to perform certain edits on the FeatureServer (this is especially true for the Toolkit.EditorWidget.GeometryServiceUrl). In order to make use of all the features of the EditorWidget you must provide a valid GeometryServiceUrl. If you do not specify a valid GeometryServiceUrl the EditorWidget features of Reshape, Union, and Cut features will not be available. The GeometryService does not need to be hosted on the same machine as where the FeatureLayer web service resides. Any public GeometryService will do.

If the functionality needed for client side editing of a FeatureLayer cannot be found using the Controls in the ESRI.ArcGIS.Client.Toolkit Assembly, developers can use the Editor Class to create their own custom editing tools. Some of the important ancillary classes that will help creating a custom editing experience include:

  • Draw Class
  • All classes in the ESRI.ArcGIS.Client.FeatureService sub-Assembly
  • All classes in the ESRI.ArcGIS.Client.Geometry sub-Assembly
  • All classes in the ESRI.ArcGIS.Client.Symbols sub-Assembly
  • Numerous classes in the ESRI.ArcGIS.Client.Tasks sub-Assembly

The FeatureLayer.Where Property is used to restrict a sub-set features returned from ArcGIS Server. In ArcGIS Server 9.3.1 and prior, the default maximum is 500 records returned per FeatureLayer. In ArcGIS Server 10 the default is 1000. This setting is configurable per map service using ArcCatalog or ArcGIS Server Manager (on the Parameters tab). The reason for restricting the number of features returned is performance. The more features returned the slower will be the rendering of the features in the FeatureLayer.

Additional conceptual documentation on the FeatureLayer can be found at: Feature layers and Editing features.

Accessing a FeatureLayer from a MapServer verses a FeatureServer
FeatureLayers are accessed via web services in ArcGIS Server. There are two ArcGIS Server web service types that enable using FeatureLayers in the API: the MapServer and the FeatureServer. Developers can use the ArcGIS REST Services Directory to discover if a FeatureLayer can be accessed via a MapServer or a FeatureServer. See the section entitled Using the ArcGIS REST Services Directory later in this document to learn how to identify which ArcGIS Server web service you can use for constructing a client-side FeatureLayer.

The API Members (i.e. Properties/Methods/Events) for the FeatureLayer that are accessed by a MapServer are read only in nature. This means you cannot make changes to the underlying features in the FeatureLayer and post them back to ArcGIS Server.

The API Members for the FeatureLayer that are accessed by a FeatureServer are editable if configured properly on ArcGIS Server. In order to perform client side editing on a FeatureLayer that is then subsequently posted back to ArcGIS Server requires the having ArcGIS Server Standard or ArcGIS Server Advanced (Note: ArcGIS Server Basic does not support web editing). Additionally, the editable data must be in an ArcSDE Geodatabase (Note: It cannot be in a shapefile, CAD drawing, KML, ArcInfo coverage, etc.).

The document ArcGIS 10 for Server Functionality Matrix is a useful downloadable .pdf file that outlines specific details of the ArcGIS Server product line and what functionality is available.

The code example in the FeatureLayer.AutoSave Property demonstrates one use-case scenario of how to set up from beginning-to-end an editable FeatureLayer via a FeatureServer. The code example demonstrates how to: 1) Add an ArcSDE Database Sever to ArcCatalog, 2) Create a new Geodatabase, 3) Populate the Geodatabase with data, 4) Register the ArcSDE Geodatabase (this enables editing using the ArcGIS Runtime SDK 1.0 for WPF), 5) Create an .mxd document in ArcMap containing the new ArcSDE Geodatabase Feature Class, 6) Publish the FeatureLayer map service on ArcGIS Server, and 7) Create a Visual Studio project to test the editing capabilities of the FeatureLayer.

The following table tells if a particular FeatureLayer Member (i.e. Property/Method/Event) in the API is useful when being accessed by a MapServer or FeatureServer.

FeatureLayer Member Useful for MapServer Useful for FeatureServer
AddAttachment Method No Yes
ClearGraphics Method Yes Yes
ClearSelection Method Yes Yes
ClearValue Method Yes Yes
CoerceValue Method Yes Yes
DeleteAttachment Method No Yes
FindGraphicsInHostCoordinate Method Yes Yes
FromJson Method Yes Yes
GetEnumerator Method Yes Yes
GetLocalValueEnumerator Method Yes Yes
GetValue Method Yes Yes
Initialize Method Yes Yes
InvalidateProperty Method Yes Yes
IsAddAttachmentAllowed Method No (Always returns False) Yes (True or False depending on the service)
IsDeleteAllowed Method No (Always returns False) Yes (True or False depending on the service)
IsDeleteAttachmentAllowed Method No (Always returns False) Yes (True or False depending on the service)
IsGeometryUpdateAllowed Method No (Always returns False) Yes (True or False depending on the service)
IsUpdateAllowed Method No (Always returns False) Yes (True or False depending on the service)
OnGraphicsSourceChanged Method No Yes
OnMapChanged Method Yes Yes
QueryAttachmentInfos Method Yes Yes
QueryLegendInfos Method Yes Yes
ReadLocalValue Method Yes Yes
Refresh Method Yes Yes
SetCurrentValue Method Yes Yes
SaveEdits Method No Yes
UndoEdits Method No Yes
Update Method No Yes
AttributionTemplate Property Yes Yes
AutoSave Property No Yes
Clusterer Property Yes Yes
Credentials Property Yes Yes
DependencyObjectType Property Yes Yes
DisableClientCaching Property Yes Yes
Dispatcher Property Yes Yes
DisplayName Property Yes Yes
EditUserName Property No Yes
Effect Property Yes Yes
ExceededTransferLimit Property Yes Yes
FullExtent Property Yes Yes
GdbVersion Property No Yes
Geometry Property Yes Yes
Graphics Property Yes Yes
GraphicsSource Property Yes Yes
HasEdits Property No Yes
ID Property Yes Yes
IgnoreServiceScaleRange Property Yes Yes
InitializationFailure Property Yes Yes
IsHitTestVisible Property Yes Yes
IsInitialized Property Yes Yes
IsReadOnly Property No (Always returns False) Yes (True or False depending on the service)
IsSealed Property Yes Yes
LayerInfo Property Yes Yes
MapTip Property Yes Yes
MaxAllowableOffset Property Yes Yes
MaximumResolution Property Yes Yes
MinimumResolution Property Yes Yes
Mode Property Yes Yes
ObjectIDs Property Yes Yes
OnDemandCacheSize Property Yes Yes
Opacity Property Yes Yes
OutFields Property Yes Yes
ProjectionService Property Yes Yes
ProxyUrl Property Yes Yes
Renderer Property Yes Yes
RendererTakesPrecedence Property Yes Yes
ReturnM Property Yes Yes
ReturnZ Property Yes Yes
SelectedGraphics Property Yes Yes
SelectionColor Property Yes Yes
SelectionCount Property Yes Yes
Source Property Yes Yes
SpatialReference Property Yes Yes
Text Property Yes Yes
TimeExtent Property Yes Yes
TimeOption Property Yes Yes
Token Property Yes Yes
Url Property Yes Yes
ValidateEdits Property No Yes
Version Property Yes Yes
Visible Property Yes Yes
VisibleTimeExtent Property Yes Yes
Where Property Yes Yes
BeginSaveEdits Event No Yes
EndSaveEdits Event No Yes
InitializationFailed Event Yes Yes
Initialized Event Yes Yes
LegendChanged Event Yes Yes
MouseEnter Event Yes Yes
MouseLeave Event Yes Yes
MouseLeftButtonDown Event Yes Yes
MouseLeftButtonUp Event Yes Yes
MouseMove Event Yes Yes
MouseRightButtonDown Yes Yes
MouseRightButtonUp Event Yes Yes
PropertyChanged Event Yes Yes
SaveEditsFailed Event No Yes
UpdateCompleted Event No Yes
UpdateFailed Event No Yes

Using the ArcGIS REST Services Directory
A very useful tool for developers to understand the capabilities of a FeatureLayer published on ArcGIS Server is the ArcGIS REST Services Directory. Simply enter the Home Url for an ArcGIS Server in the address bar of your web browser and you can begin exploring the all the ArcGIS REST Services Directory metadata information about FeatureLayer services. The typical syntax for this Home Url is: http://[EnterYourServerNameHere]/ArcGIS/rest/services. For example, the Home Url for free test ArcGIS Server web services from Esri is: http://servicesbeta2.esri.com/ArcGIS/rest/services (see the following screenshot):

Example screen shot of a free test ArcGIS Server web service from Esri.

In the ArcGIS REST Services Directory, FeatureLayers are found within map services that have the words "(MapServer)" or "(FeatureServer)" appended to the end of the map service name. Click on the hyperlink for the "[MyMapServiceName] (MapServer)" or "[MyMapServiceName] (FeatureServer)" to drill into detailed ArcGIS REST Services Directory metadata documentation that will start you on the path for discovering what FeatureLayers are available.

Once you have clicked on the hyperlink for the "[MyMapServiceName] (MapServer)" or "[MyMapServiceName] (FeatureServer)" you will see a Layers section that lists one or more individual FeatureLayer name hyperlinks with an integer value in parenthesis (this is the FeatureLayer ID index number). See the following screen shot:

Drilling into individual FeatureLayer metadata pages for a FeatureService or MapService.

When you click on an individual FeatureLayer name hyperlink in the Layers section for a (MapServer) or (FeatureServer), you then arrive on the individual metadata page for a FeatureLayer ArcGIS REST Services Directory. You can tell if you are correctly on an individual metadata page for a FeatureLayer because in the Type will be "Feature Layer". At this point you can copy the Url from the address bar of your internet browser and use this as the FeatureLayer.Url Property when defining a FeatureLayer in your client application. See the following screen shot:

Getting the FeatureLayer.Url from the ArcGIS REST Services Directory.

The following example should help to clarify this concept: Using the test ArcGIS Server web services from Esri found at the following REST Url:

http://servicesbeta2.esri.com/arcgis/rest/services/PoolPermits/FeatureServer/0

You will see in the ArcGIS REST Services Directory that the metadata contains the text: Type: Feature Layer this means that the map service could be used to define a FeatureLayer and as such you could use XAML syntax like the following (Note how the FeatureLayer ID index number is the last part of the Url after the forward slash):

            <esri:Map x:Name="Map1" 
              <esri:FeatureLayer ID="No Permit"
                    Url="http://servicesbeta2.esri.com/arcgis/rest/services/PoolPermits/FeatureServer/0"/>
            </esri:Map>
            

FeatureLayer.OutFields Property
Specifying the OutFields Property allows attribute fields to be used by other API Types such as: FeatureLayer.Where Property, ClassBreaksRenderer.Field Property, TemporalRenderer.TrackIdField Property, etc. If there are no OutFields specified, then only the OBJECTID field will be returned. The OBJECTID field is always returned under all circumstances. If an attribute field is necessary for another API Type but not returned because it was not specified in the OutFields Property, then that API type will not function as desired.

If an erroneous attribute field name is specified in the OutFields Property, no error will result. The FeatureLayer.Initialized Event will fire but no error message can be detected by the FeatureLayer.InitializationFailure Property. The FeatureLayer.UpdateCompleted Event will not fire and as a result the FeatureLayer will not display in the Map Control.

You must list the actual field names rather than the alias names. Returned fields are also the actual field names. However, you are able to use the alias names when you display the results.

For optimal performance, limit the returned attribute fields to only those you expect to use by the other API Types such as: FeatureLayer.Where Property, ClassBreaksRenderer.Field Property, TemporalRenderer.Field Property, etc. The less attribute fields returned, the less information that has to be transmitted from the web service and the faster will be the client application.

Setting the OutFields Property can be done in: 1) XAML, 2) in a code-behind function that creates a FeatureLayer dynamically at runtime, or 3) when the FeatureLayer.Initialized Event occurs. Due to the Asynchronous nature of the FeatureLayer, the Graphics (including the returned attribute fields that are specified by the OutFields Property) are not accessible until after the FeatureLayer.Initialized Event has completed. You can see valid results from specifying the OutFields in the Graphic.Attributes of the FeatureLayer.UpdateCompleted Event.

To return all fields, specify the wildcard character embedded in quotes ("*") as the value in the OutFields Property. In XAML to specify multiple individual fields in the OutFields Property, comma separate the field names in a single string (ex: "Field1, Field2, Field4").

Example

How to use:

When the application loads a FeatureLayer will automatically be added to the Map (it was specified in XAML). Click the Button to add another FeatureLayer to the Map (it will be added via code-behind). The ID of each layer will displayed in the TextBox.

The XAML code in this example is used in conjunction with the code-behind (C# or VB.NET) to demonstrate the functionality.

The following screen shot corresponds to the code example in this page.

Example of how to add a FeatureLayer in XAML and code-behind.

XAMLCopy Code
<Grid x:Name="LayoutRoot" >
  
  <!-- Add a Map Control to the application. Set the Extent the southern United States. -->
  <esri:Map x:Name="Map1" WrapAround="True" HorizontalAlignment="Left" VerticalAlignment="Top" 
            Margin="0,238,0,0" Height="350" Width="415" Extent="-12807029,2300843,-9398029,5175903">
  
    <!-- 
    Add a FeatureLayer. Wire-up the Initialized Event to display information about the layer in a TextBox.
       
    The Where clause is optional. It is necessary when more that 500/1000 records returned. In ArcGIS Server 
    9.3.1 and prior, the default maximum is 500 records returned per FeatureLayer. In ArcGIS Server 10 the 
    default is 1000. This setting is configurable per map service using ArcCatalog or ArcGIS Server Manager 
    (on the Parameters tab). In this example we use the Where clause to only return 4 features.
    
    Setting the IgnoreServiceScaleRange = "True" is helpful if the defined map service has restrictions on
    different scale levels for which the features can be viewed (ex: in the ArcGIS Services Directory REST 
    documentation these would be the 'Min. Scale' and 'Max. Scale' metadata items). The value of 
    "True" always draws the features regardless of the current map scale.
    -->
    <esri:FeatureLayer ID="TX_OK_AZ_NM_Unemployment_Rate" IgnoreServiceScaleRange="True"
          Where="ST_ABBREV = 'TX' OR ST_ABBREV = 'OK' OR ST_ABBREV = 'AZ' OR ST_ABBREV = 'NM'"
          Url="http://server.arcgisonline.com/ArcGIS/rest/services/Demographics/USA_Unemployment_Rate/MapServer/4"
          Initialized="FeatureLayer_Initialized" />
    
  </esri:Map>
  
  <!-- Add a Button that will allow the user to add another FeatureLayer via code-behind. -->
  <Button Name="Button1" Height="23" HorizontalAlignment="Left" Margin="0,209,0,0"  VerticalAlignment="Top" 
          Width="706" Content="Add another FeatureLayer (via code-behind) for the specified Url."
          Click="Button1_Click" />
  
  <!-- TextBox to display information about about the FeatureLayers added to the Map. -->
  <TextBox Height="350" HorizontalAlignment="Left" Margin="421,238,0,0" Name="TextBox1" VerticalAlignment="Top" 
           Width="285" />
  
  <!-- Provide the instructions on how to use the sample code. -->
  <TextBlock Height="174" HorizontalAlignment="Left" Name="TextBlock1" VerticalAlignment="Top" Width="788" 
             TextWrapping="Wrap" Text="When the application loads a FeatureLayer will automatically be added 
             to the Map (it was specified in XAML). Click the Button to add another FeatureLayer to the Map 
             (it will be added via code-behind). The ID of each layer will displayed in the TextBox." />
   
</Grid>
C#Copy Code
private void Button1_Click(object sender, System.Windows.RoutedEventArgs e)
{
  // This function executes as a result of the user clicking the Button. It adds an FeatureLayer
  // using code-behind.
  
  // Create an FeatureLayer. The Map1 object (a Map class) was previously defined in XAML.
  ESRI.ArcGIS.Client.FeatureLayer myFeatureLayer2 = new ESRI.ArcGIS.Client.FeatureLayer();
  
  // Set the Url of the FeatureLayer to a public service. 
  myFeatureLayer2.Url = "http://server.arcgisonline.com/ArcGIS/rest/services/Demographics/USA_Unemployment_Rate/MapServer/4";
  
  // The Where clause is optional. It is necessary when more that 500/1000 records returned. In ArcGIS Server 
  // 9.3.1 and prior, the default maximum is 500 records returned per FeatureLayer. In ArcGIS Server 10 the 
  // default is 1000. This setting is configurable per map service using ArcCatalog or ArcGIS Server Manager 
  // (on the Parameters tab). In this example we use the Where clause to only return 4 features.
  myFeatureLayer2.Where = "ST_ABBREV = 'LA' OR ST_ABBREV = 'AR' OR ST_ABBREV = 'MS' OR ST_ABBREV = 'AL'";
  
  // Setting the IgnoreServiceScaleRange = True is helpful if the defined map service has restrictions on
  // different scale levels for which the features can be viewed (ex: in the ArcGIS Services Directory REST 
  // documentation these would be the 'Min. Scale' and 'Max. Scale' metadata items). The value of 
  // True always draws the features regardless of the current map scale.
  myFeatureLayer2.IgnoreServiceScaleRange = true;
  
  // Set the ID of the FeatureLayer.
  myFeatureLayer2.ID = "LA_AR_MS_AL_Unemployment_Rate";
  
  // Wire-up the Initialized Event of the FeatureLayer. Note how a different Initialized Event
  // is being used verses the one defined in XAML. They could share the same Initialized Event but we created
  // two seperate ones for demonstration purposes.
  myFeatureLayer2.Initialized += FeatureLayer_Initialized2;
  
  // Add the FeatureLayer to the Map.
  Map1.Layers.Add(myFeatureLayer2);
}
            
private void FeatureLayer_Initialized2(object sender, EventArgs e)
{
  // This function will execute as a result of the FeatureLayer that was defined in code-behind
  // being Initialized.
  
  // Get the FeatureLayer.
  ESRI.ArcGIS.Client.FeatureLayer myFeatureLayer2 = (ESRI.ArcGIS.Client.FeatureLayer)sender;
  
  // Get the ID of the FeatureLayer.
  string myID2 = myFeatureLayer2.ID;
  
  // Create a StringBuilder object to hold information about the FeatureLayer and add some
  // useful information to it.
  System.Text.StringBuilder myStringBuilder = new System.Text.StringBuilder();
  myStringBuilder.Append(TextBox1.Text + Environment.NewLine);
  myStringBuilder.Append(Environment.NewLine);
  myStringBuilder.Append("The 2nd FeatureLayer was" + Environment.NewLine);
  myStringBuilder.Append("added via code-behind and it's ID is: " + Environment.NewLine);
  myStringBuilder.Append(myID2);
  
  // Display the results of the StringBuilder text to the user.
  TextBox1.Text = myStringBuilder.ToString();
}
            
private void FeatureLayer_Initialized(object sender, System.EventArgs e)
{
  // This function will execute as a result of the FeatureLayer that was defined in XAML
  // being Initialized.
  
  // Get the FeatureLayer.
  ESRI.ArcGIS.Client.FeatureLayer myFeatureLayer = (ESRI.ArcGIS.Client.FeatureLayer)sender;
  
  // Get the ID of the FeatureLayer.
  string myID = myFeatureLayer.ID;
  
  // Create a StringBuilder object to hold information about the FeatureLayer and add some
  // useful information to it.
  System.Text.StringBuilder myStringBuilder = new System.Text.StringBuilder();
  myStringBuilder.Append("The 1st FeatureLayer was" + Environment.NewLine);
  myStringBuilder.Append("added via XAML and it's ID is: " + Environment.NewLine);
  myStringBuilder.Append(myID);
  
  // Display the results of the StringBuilder text to the user.
  TextBox1.Text = myStringBuilder.ToString();
}
VB.NETCopy Code
Private Sub Button1_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
  
  ' This function executes as a result of the user clicking the Button. It adds an FeatureLayer
  ' using code-behind.
  
  ' Create an FeatureLayer. The Map1 object (a Map class) was previously defined in XAML.
  Dim myFeatureLayer2 As New ESRI.ArcGIS.Client.FeatureLayer
  
  ' Set the Url of the FeatureLayer to a public service. 
  myFeatureLayer2.Url = "http://server.arcgisonline.com/ArcGIS/rest/services/Demographics/USA_Unemployment_Rate/MapServer/4"
  
  ' The Where clause is optional. It is necessary when more that 500/1000 records returned. In ArcGIS Server 
  ' 9.3.1 and prior, the default maximum is 500 records returned per FeatureLayer. In ArcGIS Server 10 the 
  ' default is 1000. This setting is configurable per map service using ArcCatalog or ArcGIS Server Manager 
  ' (on the Parameters tab). In this example we use the Where clause to only return 4 features.
  myFeatureLayer2.Where = "ST_ABBREV = 'LA' OR ST_ABBREV = 'AR' OR ST_ABBREV = 'MS' OR ST_ABBREV = 'AL'"
  
  ' Setting the IgnoreServiceScaleRange = True is helpful if the defined map service has restrictions on
  ' different scale levels for which the features can be viewed (ex: in the ArcGIS Services Directory REST 
  ' documentation these would be the 'Min. Scale' and 'Max. Scale' metadata items). The value of 
  ' True always draws the features regardless of the current map scale.
  myFeatureLayer2.IgnoreServiceScaleRange = True
  
  ' Set the ID of the FeatureLayer.
  myFeatureLayer2.ID = "LA_AR_MS_AL_Unemployment_Rate"
  
  ' Wire-up the Initialized Event of the FeatureLayer. Note how a different Initialized Event
  ' is being used verses the one defined in XAML. They could share the same Initialized Event but we created
  ' two seperate ones for demonstration purposes.
  AddHandler myFeatureLayer2.Initialized, AddressOf FeatureLayer_Initialized2
  
  ' Add the FeatureLayer to the Map.
  Map1.Layers.Add(myFeatureLayer2)
  
End Sub
            
Private Sub FeatureLayer_Initialized2(sender As Object, e As EventArgs)
  
  ' This function will execute as a result of the FeatureLayer that was defined in code-behind
  ' being Initialized.
  
  ' Get the FeatureLayer.
  Dim myFeatureLayer2 As ESRI.ArcGIS.Client.FeatureLayer = CType(sender, ESRI.ArcGIS.Client.FeatureLayer)
  
  ' Get the ID of the FeatureLayer.
  Dim myID2 As String = myFeatureLayer2.ID
  
  ' Create a StringBuilder object to hold information about the FeatureLayer and add some
  ' useful information to it.
  Dim myStringBuilder As New System.Text.StringBuilder
  myStringBuilder.Append(TextBox1.Text + vbCrLf)
  myStringBuilder.Append(vbCrLf)
  myStringBuilder.Append("The 2nd FeatureLayer was" + vbCrLf)
  myStringBuilder.Append("added via code-behind and it's ID is: " + vbCrLf)
  myStringBuilder.Append(myID2)
  
  ' Display the results of the StringBuilder text to the user.
  TextBox1.Text = myStringBuilder.ToString
  
End Sub
            
Private Sub FeatureLayer_Initialized(sender As System.Object, e As System.EventArgs)
  
  ' This function will execute as a result of the FeatureLayer that was defined in XAML
  ' being Initialized.
  
  ' Get the FeatureLayer.
  Dim myFeatureLayer As ESRI.ArcGIS.Client.FeatureLayer = CType(sender, ESRI.ArcGIS.Client.FeatureLayer)
  
  ' Get the ID of the FeatureLayer.
  Dim myID As String = myFeatureLayer.ID
  
  ' Create a StringBuilder object to hold information about the FeatureLayer and add some
  ' useful information to it.
  Dim myStringBuilder As New System.Text.StringBuilder
  myStringBuilder.Append("The 1st FeatureLayer was" + vbCrLf)
  myStringBuilder.Append("added via XAML and it's ID is: " + vbCrLf)
  myStringBuilder.Append(myID)
  
  ' Display the results of the StringBuilder text to the user.
  TextBox1.Text = myStringBuilder.ToString
  
End Sub

Inheritance Hierarchy

System.Object
   System.Windows.Threading.DispatcherObject
      System.Windows.DependencyObject
         ESRI.ArcGIS.Client.Layer
            ESRI.ArcGIS.Client.GraphicsLayer
               ESRI.ArcGIS.Client.FeatureLayer
                  ESRI.ArcGIS.Client.Local.ArcGISLocalFeatureLayer

Requirements

Target Platforms: Windows XP Professional, Windows Server 2003 family, Windows Vista, Windows Server 2008 family, Windows 7, Windows 8

See Also

© ESRI, Inc. All Rights Reserved.