ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Data.UtilityNetwork Namespace / NetworkAttribute Class / Name Property
Example

In This Topic
    Name Property (NetworkAttribute)
    In This Topic
    Gets the name of the network attribute.
    Syntax
    public string Name {get;}
    Public ReadOnly Property Name As String
    Example
    Export a utility network trace as a JSON file
    {
      // This routine demonstrates how to perform a trace and export the results as a JSON file
      static void ExportUtilityNetworkTraceAsJSON(UtilityNetwork utilityNetwork)
      {
        using (TraceManager traceManager = utilityNetwork.GetTraceManager())
        using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
        using (NetworkSource deviceNetworkSource = GetNetworkSource(utilityNetworkDefinition, "GasDevice") as NetworkSource)
        using (FeatureClass distributionDeviceFeatureClass = utilityNetwork.GetTable(deviceNetworkSource) as FeatureClass)
        using (FeatureClassDefinition distributionDeviceDefinition = distributionDeviceFeatureClass.GetDefinition())
        using (AssetGroup deviceAssetGroup = deviceNetworkSource.GetAssetGroup("Regulator"))
        using (AssetType deviceAssetType = deviceAssetGroup.GetAssetType("Pressure Reducing"))
        using (NetworkAttribute deviceStatusNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute("DeviceStatus"))
        using (NetworkAttribute accessibleNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute("Accessible"))
        {
          // Domain and tier information
          DomainNetwork domainNetwork = utilityNetworkDefinition.GetDomainNetwork("Gas");
          Tier pipeDistributionSystemTier = domainNetwork.GetTier("Pipe Distribution");
    
          // Start elements
          Element startingPoint1 = utilityNetwork.CreateElement(deviceAssetType, Guid.Parse("{28CF437E-950C-41B7-B839-8BC45570DE40}"));
          Element startingPoint2 = utilityNetwork.CreateElement(deviceAssetType, Guid.Parse("{63C22828-7BC9-49ED-A14A-A596559B6CB3}"));
    
          startingPoint1.Terminal = startingPoint1.AssetType.GetTerminalConfiguration().Terminals
            .First(x => x.IsUpstreamTerminal);
          startingPoint2.Terminal = startingPoint2.AssetType.GetTerminalConfiguration().Terminals
            .First(x => x.IsUpstreamTerminal);
    
          List<Element> startingPoints = [startingPoint1, startingPoint2];
          List<Element> barriers = [];
    
          // Set up trace filter: DeviceStatus = Open (1) AND Accessible = 1
          NetworkAttributeComparison statusNetworkAttributeComparison = new NetworkAttributeComparison(deviceStatusNetworkAttribute, Operator.Equal, 1);
          NetworkAttributeComparison networkAttributeComparison = new NetworkAttributeComparison(accessibleNetworkAttribute, Operator.Equal, 1);
    
          // Set trace configuration
          TraceConfiguration traceConfiguration = new TraceConfiguration
          {
            AllowIndeterminateFlow = true,
            IgnoreBarriersAtStartingPoints = false,
            IncludeBarriersWithResults = true,
            IncludeContainers = true,
            IncludeContent = true,
            IncludeIsolatedFeatures = false,
            IncludeUpToFirstSpatialContainer = false
          };
    
          traceConfiguration.Filter.Barriers = new And(statusNetworkAttributeComparison, networkAttributeComparison);
          traceConfiguration.DomainNetwork = domainNetwork;
          traceConfiguration.SourceTier = pipeDistributionSystemTier;
    
          // Attribute fields of a network source
          List<string> deviceFields = distributionDeviceDefinition.GetFields().Select(f => f.Name).ToList();
    
          // Network attributes
          List<string> networkattributeNames = new List<string>();
    
          IReadOnlyList<NetworkAttribute> networkAttributes = utilityNetworkDefinition.GetNetworkAttributes();
    
          foreach (NetworkAttribute networkAttribute in networkAttributes)
          {
            networkattributeNames.Add(networkAttribute.Name);
          }
    
          // Result Types
          List<ResultType> resultTypeList = new List<ResultType>() { ResultType.Feature };
    
          // Resutl Options
          ResultOptions resultOptions = new ResultOptions()
          {
            IncludeGeometry = true,
            NetworkAttributes = networkattributeNames,
            ResultFields = new Dictionary<NetworkSource, List<string>>() { { deviceNetworkSource, deviceFields } }
          };
    
          // Trace Arguments
          TraceArgument traceArgument = new TraceArgument(startingPoints)
          {
            Barriers = barriers,
            Configuration = traceConfiguration,
            ResultTypes = resultTypeList,
            ResultOptions = resultOptions
          };
    
          ConnectedTracer connectedTracer = traceManager.GetTracer<ConnectedTracer>();
    
          // Set export options
          TraceExportOptions exportOptions = new TraceExportOptions()
          {
            ServiceSynchronizationType = ServiceSynchronizationType.Asynchronous,
            IncludeDomainDescriptions = true,
          };
    
          // Path to export JSON
          string jsonPath = $"{Path.GetTempPath()}TraceResults.json";
          Uri jsonUri = new Uri(jsonPath);
    
          // Export
          connectedTracer.Export(jsonUri, traceArgument, exportOptions);
    
          string jsonAbsolutePath = HttpUtility.UrlDecode(jsonUri.AbsolutePath);
          if (jsonUri.IsFile && File.Exists(jsonAbsolutePath))
          {
            // Work with the JSON results
          }
        }
    
        NetworkSource GetNetworkSource(UtilityNetworkDefinition unDefinition, string name)
        {
          IReadOnlyList<NetworkSource> allSources = unDefinition.GetNetworkSources();
          foreach (NetworkSource source in allSources)
          {
            if (name.Contains("Partitioned Sink"))
            {
              if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()) ||
                  source.Name.Replace(" ", "").ToUpper()
                    .Contains(name.Replace("Partitioned Sink", "Part_Sink").Replace(" ", "").ToUpper()))
              {
                return source;
              }
            }
    
            if (name.Contains("Hierarchical Sink"))
            {
              if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()) ||
                  source.Name.Replace(" ", "").ToUpper()
                    .Contains(name.Replace("Hierarchical Sink", "Hier_Sink").Replace(" ", "").ToUpper()))
              {
                return source;
              }
            }
    
            if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()))
            {
              return source;
            }
          }
          return null;
        }
      }
    }
    Fetch features and network attributes from a utility network during trace
    {
      // This routine demonstrates how to fetch features and network attributes from a utility network during a trace
      static void FetchFeaturesAndAttributes(UtilityNetwork utilityNetwork)
      {
        using (Geodatabase geodatabase = utilityNetwork.GetDatastore() as Geodatabase)
        using (TraceManager traceManager = utilityNetwork.GetTraceManager())
        using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
        using (NetworkSource deviceNetworkSource = GetNetworkSource(utilityNetworkDefinition, "GasDevice") as NetworkSource)
        using (FeatureClass distributionDeviceFeatureClass = utilityNetwork.GetTable(deviceNetworkSource) as FeatureClass)
        using (FeatureClassDefinition distributionDeviceDefinition = distributionDeviceFeatureClass.GetDefinition())
        using (AssetGroup deviceAssetGroup = deviceNetworkSource.GetAssetGroup("Regulator"))
        using (AssetType deviceAssetType = deviceAssetGroup.GetAssetType("Pressure Reducing"))
        using (NetworkAttribute deviceStatusNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute("DeviceStatus"))
        using (NetworkAttribute accessibleNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute("Accessible"))
        using (RelationshipClass valveInspectionRelationshipClass = geodatabase.OpenDataset<RelationshipClass>("GasDeviceToValveInspection"))
        using (Table valveInspection = geodatabase.OpenDataset<Table>("ValveInspection"))
        using (TableDefinition valveInspectionDefn = valveInspection.GetDefinition())
        {
          // Domain and tier information
          DomainNetwork domainNetwork = utilityNetworkDefinition.GetDomainNetwork("Gas");
          Tier pipeDistributionSystemTier = domainNetwork.GetTier("Pipe Distribution");
    
          // Start elements
          Element startingPoint1 = utilityNetwork.CreateElement(deviceAssetType, Guid.Parse("{28CF437E-950C-41B7-B839-8BC45570DE40}"));
          Element startingPoint2 = utilityNetwork.CreateElement(deviceAssetType, Guid.Parse("{63C22828-7BC9-49ED-A14A-A596559B6CB3}"));
    
          startingPoint1.Terminal = startingPoint1.AssetType.GetTerminalConfiguration().Terminals
            .First(x => x.IsUpstreamTerminal);
          startingPoint2.Terminal = startingPoint2.AssetType.GetTerminalConfiguration().Terminals
            .First(x => x.IsUpstreamTerminal);
    
          List<Element> startingPoints = new List<Element>() { startingPoint1, startingPoint2 };
          List<Element> barriers = new List<Element>();
    
          // Set up trace filter: DeviceStatus = Open (1) AND Accessible = 1
          NetworkAttributeComparison statusNetworkAttributeComparison = new NetworkAttributeComparison(deviceStatusNetworkAttribute, Operator.Equal, 1);
          NetworkAttributeComparison networkAttributeComparison = new NetworkAttributeComparison(accessibleNetworkAttribute, Operator.Equal, 1);
    
          // Set trace configuration
          TraceConfiguration traceConfiguration = new TraceConfiguration
          {
            AllowIndeterminateFlow = true,
            IgnoreBarriersAtStartingPoints = false,
            IncludeBarriersWithResults = true,
            IncludeContainers = true,
            IncludeContent = true,
            IncludeIsolatedFeatures = false,
            IncludeUpToFirstSpatialContainer = false
          };
    
          traceConfiguration.Filter.Barriers = new And(statusNetworkAttributeComparison, networkAttributeComparison);
          traceConfiguration.DomainNetwork = domainNetwork;
          traceConfiguration.SourceTier = pipeDistributionSystemTier;
    
          // Attribute fields of a network source
          List<string> deviceFields = distributionDeviceDefinition.GetFields().Select(f => f.Name).ToList();
    
          // Network attributes
          List<string> networkattributeNames = new List<string>();
    
          IReadOnlyList<NetworkAttribute> networkAttributes = utilityNetworkDefinition.GetNetworkAttributes();
    
          foreach (NetworkAttribute networkAttribute in networkAttributes)
          {
            networkattributeNames.Add(networkAttribute.Name);
          }
    
          // Get the field names for the related records table (ValveInspection)
          IReadOnlyList<Field> valveRelatedRecords = valveInspectionDefn.GetFields();
          List<string> valveFieldNames = valveRelatedRecords.Select(f => f.Name).ToList();
    
          // Result Types
          List<ResultType> resultTypeList = new List<ResultType>() { ResultType.Feature, ResultType.RelatedRecord };
    
          // Resutl Options
          ResultOptions resultOptions = new ResultOptions()
          {
            IncludeGeometry = true,
            NetworkAttributes = networkattributeNames,
            ResultFields = new Dictionary<NetworkSource, List<string>>() { { deviceNetworkSource, deviceFields } },
            RelatedRecordFields = new Dictionary<RelationshipClass, List<string>>() { { valveInspectionRelationshipClass, valveFieldNames } }
          };
    
          // Trace Arguments
          TraceArgument traceArgument = new TraceArgument(startingPoints)
          {
            Barriers = barriers,
            Configuration = traceConfiguration,
            ResultTypes = resultTypeList,
            ResultOptions = resultOptions
          };
    
          // Tracer
          ConnectedTracer connectedTracer = traceManager.GetTracer<ConnectedTracer>();
    
          // Async trace result
          IReadOnlyList<Result> traceResults =
            connectedTracer.Trace(traceArgument, ServiceSynchronizationType.Asynchronous);
    
          // Iterate trace results
          foreach (Result traceResult in traceResults)
          {
            if (traceResult is FeatureElementResult featureElementResult)
            {
              IReadOnlyList<FeatureElement> featureElements = featureElementResult.FeatureElements;
    
              // Iterate through the feature elements
              foreach (FeatureElement featureElement in featureElements)
              {
                // Get the field values specified in the `ResultOptions`
                IReadOnlyList<TraceResultFieldValue> resultFieldValues = featureElement.ResultFieldValues;
    
                foreach (TraceResultFieldValue fieldValue in resultFieldValues)
                {
                  if (fieldValue.FieldType == FieldType.Geometry)
                  {
                    // Get the geometry of the feature
                    Geometry geometry = fieldValue.Value as Geometry;
                  }
                }
                // Get the Network attribute values specified in the `ResultOptions`
                IReadOnlyList<TraceResultFieldValue> networkAttributeValues = featureElement.ResultNetworkAttributeValues;
              }
            }
    
            if (traceResult is RelatedRecordResult relatedRecordResult)
            {
              IReadOnlyList<RelatedRecord> relatedRecords = relatedRecordResult.RelatedRecords;
              // Iterate through the related records
              foreach (RelatedRecord relatedRecord in relatedRecords)
              {
                IReadOnlyList<RelationshipClassValue> relationshipClassValues = relatedRecord.RelationshipClassValues;
                foreach (RelationshipClassValue relationshipClassValue in relationshipClassValues)
                {
                  // Access the IDs and name associated with this relationship class
                  var destinationId = relationshipClassValue.DestinationID;
                  var name = relationshipClassValue.Name;
                  var originId = relationshipClassValue.OriginID;
    
                  // Access the relationship values associated with this relationship class 
                  IReadOnlyList<RelationshipValue> relationshipValues = relationshipClassValue.RelationshipValues;
                  foreach (RelationshipValue relationshipValue in relationshipValues)
                  {
                    // Geometry associated with this relationship value
                    Geometry geometry = relationshipValue.Geometry;
    
                    // Out fields associated with non attributed relationship class
                    IReadOnlyList<TraceResultFieldValue> outFields = relationshipValue.OutFields;
    
                    // Out fields associated with attributed relationship class
                    // IReadOnlyList<TraceResultFieldValue> relationshipOutFields = relationshipValue.RelationshipOutFields;
                  }
                }
              }
            }
          }
        }
    
        // Helper inline function
        NetworkSource GetNetworkSource(UtilityNetworkDefinition unDefinition, string name)
        {
          IReadOnlyList<NetworkSource> allSources = unDefinition.GetNetworkSources();
          foreach (NetworkSource source in allSources)
          {
            if (name.Contains("Partitioned Sink"))
            {
              if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()) ||
                  source.Name.Replace(" ", "").ToUpper()
                    .Contains(name.Replace("Partitioned Sink", "Part_Sink").Replace(" ", "").ToUpper()))
              {
                return source;
              }
            }
    
            if (name.Contains("Hierarchical Sink"))
            {
              if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()) ||
                  source.Name.Replace(" ", "").ToUpper()
                    .Contains(name.Replace("Hierarchical Sink", "Hier_Sink").Replace(" ", "").ToUpper()))
              {
                return source;
              }
            }
    
            if (source.Name.Replace(" ", "").ToUpper().Contains(name.Replace(" ", "").ToUpper()))
            {
              return source;
            }
          }
    
          return null;
        }
      }
    }
    Export circuits
    await QueuedTask.Run(() =>
    {
      using (TraceManager traceManager = utilityNetwork.GetTraceManager())
      using (CircuitManager circuitManager = utilityNetwork.GetCircuitManager(telecomDomainNetwork))
      using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
      {
        IReadOnlyList<NetworkSource> networkSources = utilityNetworkDefinition.GetNetworkSources();
        IReadOnlyList<NetworkAttribute> networkAttributes = utilityNetworkDefinition.GetNetworkAttributes();
        IEnumerable<string> networkAttributeNames = networkAttributes.Select(s => s.Name);
    
        NetworkSource telcoDeviceNWSource = networkSources.First(f => f.Name.Contains("TelcoDevice"));
        NetworkSource telcoCircuit = networkSources.First(f => f.Name.Contains("TelcoCircuit"));
    
        TraceConfiguration traceConfiguration = new TraceConfiguration()
        {
          InferConnectivity = false,
          DomainNetwork = telecomDomainNetwork,
          IncludeContainers = true,
          IncludeContent = true,
          SynthesizeGeometries = false
        };
    
        ResultOptions resultOptions = new ResultOptions()
        {
          IncludeGeometry = true,
          NetworkAttributes = networkAttributeNames.ToList(),
          ResultFields = new Dictionary<NetworkSource, List<string>>() { { telcoDeviceNWSource, ["NEXTUNITID", "PARTITIONID"] },
            { telcoCircuit, ["LongTestField", "TextTestField", "DateTestField"] }}
        };
    
        CircuitExportOptions circuitExportOptions = new CircuitExportOptions()
        {
          IncludeDomainDescriptions = true,
          ResultOptions = resultOptions,
          ResultTypes = new List<ResultType> { ResultType.Circuit },
          ServiceSynchronizationType = ServiceSynchronizationType.Asynchronous,
          SetAcknowledged = false,
          TraceConfiguration = traceConfiguration
        };
    
        circuitManager.Export(circuitNames, circuitExportOptions, circuitExportPath);
      }
    });
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also