public class KnowledgeGraphCentralityResults 

//using ArcGIS.Core.Data.Knowledge.Extensions;

await QueuedTask.Run(() =>
{

  //use defaults...
  var kg_config = new CIMKnowledgeGraphCentralityConfiguration();

  //include all entities from the kg in the subgraph
  //(no filters)
  var kg_subgraph = new CIMKnowledgeGraphSubGraph();

  //include all centrality measures
  CentralityMeasure[] measures = [
    CentralityMeasure.Degree,
    CentralityMeasure.InDegree,
    CentralityMeasure.OutDegree,
    CentralityMeasure.Coreness,
    CentralityMeasure.Betweenness,
    CentralityMeasure.Closeness,
    CentralityMeasure.Harmonic,
    CentralityMeasure.Eigenvector,
    CentralityMeasure.PageRank
  ];

  //compute centrality
  var kg_centrality_results = kg.ComputeCentrality(
                                    kg_config, kg_subgraph, measures);
  //output results - results include measure scores for all entities
  //in all types in the subgraph
  System.Diagnostics.Debug.WriteLine("Centrality Results:");
  foreach (var named_type in kg_centrality_results.NamedTypes)
  {
    System.Diagnostics.Debug.WriteLine($"Named type: {named_type}");
    foreach (var uid in kg_centrality_results.GetUidsForNamedType(named_type))
    {
      //measure scores include one score per measure in the input measures array
      var scores = kg_centrality_results.Scores[uid];
      StringBuilder sb = new StringBuilder();
      var sep = "";
      //or use kg_centrality_results.Scores.Measures.Length
      //kg_centrality_results.Scores.Measures is there for convenience
      for (int m = 0; m < measures.Length; m++)
      {
        sb.Append($"{sep}{measures[m].ToString()}: {scores[m]}");
        sep = ", ";
      }
      System.Diagnostics.Debug.WriteLine($"  '{uid}' {sb.ToString()}");
    }
  }
});

//using ArcGIS.Core.Data.Knowledge.Extensions;

await QueuedTask.Run(() =>
{
  ///var config = ...;
  //var subGraph = ...;
  //var measures = ...;

  var results = kg.ComputeCentrality(config, subGraph, measures);
  //loop through each (entity) named type (relates are never included in results)
  foreach (var named_type in results.NamedTypes)
  {
    //Get the entity uids for each named type
    foreach (var uid in results.GetUidsForNamedType(named_type))
    {
      //Get the scores for each uid via the [] indexer on "Scores"
      var scores = results.Scores[uid];
      //There is one score per measure in the input measures array
      //Note: results.Scores.Measures is also provided for convenience...
      //for (int m = 0; m < results.Scores.Measures.Length; m++)
      for (int m = 0; m < measures.Length; m++)
      {
        var score = scores[m];//score for the given measure
                                //TODO - use measure score

      }
    }
  }
});

      //using ArcGIS.Core.Data.Knowledge.Extensions;

      //var results = kg.ComputeCentrality(...);
      var count_entities = results.RawUids.Count();
var score_len = results.Scores.RawScores.Length;
//Find the max and min score for each measure w/out
//using LINQ or sorting
for (int m = 0; m < results.Scores.Measures.Length; m++)
{
  //index into the scores array for the current measure
  var start_idx = count_entities * m;
  var end_idx = start_idx + count_entities;

  double max_score = double.MinValue;
  double min_score = double.MaxValue;
  List<object> max_uids = new List<object>();
  List<object> min_uids = new List<object>();

  for (int i = 0, s = start_idx; s < end_idx; i++, s++)
  {
    var score = results.Scores.RawScores[s];
    //max
    if (score > max_score)
    {
      max_score = score;
      max_uids.Clear();
      max_uids.Add(results.RawUids[i]);
    }
    else if (score == max_score)
    {
      //Collect all uids with the max score
      max_uids.Add(results.RawUids[i]);
    }
    //min
    if (score < min_score)
    {
      min_score = score;
      min_uids.Clear();
      min_uids.Add(results.RawUids[i]);
    }
    else if (score == min_score)
    {
      //Collect all uids with the min score
      min_uids.Add(results.RawUids[i]);
    }
  }
  //TODO - use the max and min scores and uids for
  //the current measure "measures[m]"
  //max_score, max_uids
  //min_score, min_uids

}

      //using ArcGIS.Core.Data.Knowledge.Extensions;

      //var results = kg.ComputeCentrality(...);

      var count_entities = results.RawUids.Count();
var score_len = results.Scores.RawScores.Length;
//Find the max and min score for each measure using LINQ
for (int m = 0; m < results.Scores.Measures.Length; m++)
{
  //index into the scores array for the current measure
  var start_idx = count_entities * m;
  var end_idx = start_idx + count_entities;

  //Get the scores for the specified measure
  var scores = Enumerable.Range(start_idx, count_entities)
    .Select(i => results.Scores.RawScores[i]).ToArray();

  //max + min
  var max_score = scores.Max();
  var min_score = scores.Min();

  //uids with the max score
  var max_uids = Enumerable.Range(0, count_entities)
                   .Where(i => scores[i] == max_score)
                   .Select(i => results.RawUids[i])
                   .ToList();

  //uids with the min score
  var min_uids = Enumerable.Range(0, count_entities)
                   .Where(i => scores[i] == min_score)
                   .Select(i => results.RawUids[i])
                   .ToList();
  //TODO - use the max and min scores and uids for
  //the current measure "measures[m]"
  //max_score, max_uids
  //min_score, min_uids
}

      //using ArcGIS.Core.Data.Knowledge.Extensions;

      //Note: logic uses the following custom class:
      //
      //public class KG_Score_Value {
      //   public KG_Score_Value(double score, int uid_idx) {
      //      Score = score;
      //      Uid_idx = uid_idx;
      //   }
      //
      //   public double Score { get; set; }
      //   public int Uid_idx { get; set; }
      //}

      //var results = kg.ComputeCentrality(...);

      var count_entities = results.RawUids.Count();
var score_len = results.Scores.RawScores.Length;

//Find the top and bottom "n" scores for each measure
for (int m = 0; m < results.Scores.Measures.Length; m++)
{
  //index into the scores array for the current measure
  var start_idx = count_entities * m;
  var end_idx = start_idx + count_entities;

  //Get the scores for the specified measure
  var scores = Enumerable.Range(start_idx, count_entities)
    .Select(i => results.Scores.RawScores[i]).ToArray();

  //use "KG_Score_Value" to hold the score and uid index
  var uid_idx = 0;
  var kg_score_vals = Enumerable.Range(start_idx, count_entities)
         .Select(i => new KG_Score_Value(results.Scores.RawScores[i], uid_idx++))
         .OrderByDescending(k => k.Score)
         .ToArray();

  //get up to the top or bottom N scores
  if (n > kg_score_vals.Length)
    n = kg_score_vals.Length;

  //get the top N scores and uids - largest first
  var top_n = kg_score_vals.Take(n).ToList();

  //get the bottom N scores and uids - smallest first
  var bottom_n = kg_score_vals.TakeLast(n)
                    .Reverse().ToList();

  foreach (var kg_score in top_n)
  {
    //TODO - use top "n" scores
    var score = kg_score.Score;
    var uid = results.RawUids[kg_score.Uid_idx];
    //...use it
  }

  foreach (var kg_score in bottom_n)
  {
    //TODO - use bottom "n" scores
    var score = kg_score.Score;
    var uid = results.RawUids[kg_score.Uid_idx];
    //...use it
  }
}