ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Data.UtilityNetwork.Trace Namespace / RelatedRecordResult Class
Members Example

In This Topic
    RelatedRecordResult Class
    In This Topic
    Represents the result of RelatedRecord information from a trace output.
    Syntax
    public sealed class RelatedRecordResult : Result 
    Public NotInheritable Class RelatedRecordResult 
       Inherits Result
    Example
    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;
        }
      }
    }
    Inheritance Hierarchy

    System.Object
       ArcGIS.Core.Data.UtilityNetwork.Trace.Result
          ArcGIS.Core.Data.UtilityNetwork.Trace.RelatedRecordResult

    Requirements

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

    ArcGIS Pro version: 3.8 or higher.
    See Also