C# JToken.Values方法代码示例

 private ITask GetTask(JToken token)
 {
     var taskName = token.Values<JProperty>().SingleOrDefault(i => i.Name == "TaskName").Value.ToString();
     if (string.IsNullOrWhiteSpace(taskName)) return null;
     var taskType = _taskMapper[taskName];
     if (taskType == null) return null;
     return GetTask(token, taskType);
 }

 private void Load(JToken jToken)
 {
     foreach (JToken token in jToken.Values())
     {
         if (token.Type == JTokenType.String)
         {
             var key = ConfigurationPath.Combine(GetPathTokens(token.Path));
             Data[key] = ((JValue)token).Value as string;
         } else
         {
             Load(token);
         }
     }
 }

 private string ReadJsonLeaf(JToken jToken)
 {
     if (jToken.HasValues)
     {
         foreach (JToken value in jToken.Values())
         {
             return ReadJsonLeaf(value);
         }
     }
     else
     {
         if (jToken is JValue)
         {
             JValue jValue = (JValue)jToken;
             return jValue.Value.ToString();
         }
     }
     return string.Empty;
 }

        private static JToken GetQueryToken(JToken root)
        {
            if (!root.HasValues) return null;

            return root["query"] ?? root.Values().Select(GetQueryToken).FirstOrDefault(query => query != null);
        }

 static void RecursiveTree(String path, JToken Tree, ShaTree ThisShaTree, String repo)
 {
     Directory.CreateDirectory(path);
     foreach (JProperty fileProp in Tree.Values<JProperty>())
     {
         JToken file = fileProp.Value;
         if ((String)file["type"] == "tree")
         {
             if (!ThisShaTree.SubTrees.ContainsKey((String)file["path"]))
             {
                 ThisShaTree.SubTrees.Add((String)file["path"], new ShaTree());
             }
             RecursiveTree(path + "\\" + (String)file["path"], file["tree"], ThisShaTree.SubTrees[(String)file["path"]], repo);
         }
         else
         {
             if (((String)file["path"])[0] != '.')
             {
                 if (!ThisShaTree.FileShas.ContainsKey((String)file["path"]))
                 {
                     ThisShaTree.FileShas.Add((String)file["path"], "");
                 }
                 if (ThisShaTree.FileShas[(String)file["path"]] != (String)file["sha"])
                 {
                     ThisShaTree.FileShas[(String)file["path"]] = (String)file["sha"];
                     UpdateFile(path + "\\" + (String)file["path"], repo, (String)file["sha"]);
                     InnerSpace.Echo((String)file["path"] + " Downloaded");
                 }
             }
         }
     }
 }

 private List<String> ParseProtocol(JToken protocols)
 {
     return protocols.Values<String>().ToList();
 }

 private Dictionary<String, String> ParseId(JToken ids)
 {
     Dictionary<String, String> returnValues = new Dictionary<String, String>();
     foreach (JProperty id in ids.Values())
     {
         returnValues.Add(id.Name, (String)id.Value);
     }
     return returnValues;
 }

        /*
         * Gets all the sub-categories (or topics?) of jt, and hangs them under node?
         */
        //private static void decipherAreasJSON(JToken jt, Node node)
        private static void decipherAreasJSON(JToken jt, Category group)
        {
            if (jt is JProperty)
            {
                if (jt.ToObject<JProperty>().Name != IFIXIT_CATEGORY_OBJECT_KEY)
                {
            //                    Debug.WriteLine(" " + jt.ToObject<JProperty>().Name);

                    // since it's not a device, it must be a group
                    //Node curr = new Node(jt.ToObject<JProperty>().Name, new List<Node>());
                    Category curr = new Category(jt.ToObject<JProperty>().Name);

                    //FIXME this is where we add to the 1:M, right?
                    //group.Categories.Add(curr);
                    group.AddCategory(curr);
                    curr.Parent = group;
                    curr.parentName = group.Name;
                    if (jt.HasValues)
                    {
                        IJEnumerable<JToken> values = jt.Values();
                        foreach (JToken val in values)
                        {
                            decipherAreasJSON(val, curr);
                        }
                    }
                }
                // these are devices
                else
                {
                    IJEnumerable<JToken> devs = jt.Values();
                    foreach (JToken dev in devs)
                    {
                        Topic d = new Topic();
                        d.Name = dev.ToString();
                        /*
                        if (group.Devices == null)
                        {
                            group.Devices = new List<Topic>();
                        }
                         */
                        //group.Topics.Add(d);
                        group.AddTopic(d);
                        d.Parent = group;
                        d.parentName = group.Name;

                        //node.getChildrenList().Add(new Node(dev.ToString(), null));
            //                        Debug.WriteLine("  " + dev.ToString());
                    }
                }
            }
            else
            {
                // can currently safely ignore anything in this category
            //                Debug.WriteLine("\n" + jt.ToString() + " not a property\n");
            }
        }

 private string GetName(JToken token)
 {
     if (token.Type == JTokenType.Object)
         return token.Values<JProperty>().FirstOrDefault(i => i.Name == "TaskCaption").Value.ToString();
     if (token.Type == JTokenType.Property)
     {
         var prop = (JProperty)token;
         if (IsTokenScalarValue(prop.Value))
             return string.Format("{0}: {1}", prop.Name, prop.Value.ToString());
         else
             return prop.Name;
     }
     return token.ToString();
 }

		/// <summary>
		/// Loads the extenders from the JSON token provided
		/// </summary>
		/// <param name="extendersJson">The JSON token from which to load the extenders</param>
		/// <returns></returns>
		private static IList<ExtenderConfig> LoadExtenders(JToken extendersJson)
		{
			var extenders = new List<ExtenderConfig>();

			// Make sure we have something to work with
			if (extendersJson != null)
			{
				// If it is an array, iterate over it and create a new
				//  extender config for each entry
				if (extendersJson.Type == JTokenType.Array)
				{
					foreach (var extenderJson in extendersJson.Values())
					{
						extenders.Add(new ExtenderConfig(extenderJson));
					}
				}
				// If it is a single item, instantiate that
				else
				{
					extenders.Add(new ExtenderConfig(extendersJson));
				}
			}

			// Return what we got, if anything
			return extenders;
		}

		/// <summary>
		/// Loads the static meta data providers from the configuration JSON token provided
		/// </summary>
		/// <param name="staticMetaDataProvidersJson">The JSON token containing the static meta data providers</param>
		/// <returns>A list of names of static meta data providers</returns>
		private static IList<string> LoadStaticMetaDataProviders(JToken staticMetaDataProvidersJson)
		{
			return staticMetaDataProvidersJson != null && staticMetaDataProvidersJson.Type == JTokenType.Array
				? staticMetaDataProvidersJson.Values<string>().ToList<string>()
				: new List<string>();
		}

		/// <summary>
		/// Loads the configuration extenders from the configuration JSON token provided
		/// </summary>
		/// <param name="configExtendersJson">The JSON token containing the configuration extenders</param>
		/// <returns>A list of names of configuration extenders</returns>
		private static IList<string> LoadConfigurationExtenders(JToken configExtendersJson)
		{
			return configExtendersJson != null && configExtendersJson.Type == JTokenType.Array
				? configExtendersJson.Values<string>().ToList<string>()
				: new List<string>();
		}

        /// <summary>
        /// Get the tags in a token that contains tags
        /// This is used to get message tags and description tags
        /// </summary>
        /// <param name="token">The description token</param>
        private static IList<SWTag> getTags(JToken token)
        {
            if (!tokenHasValue(token)) return null;

              IList<SWTag> result = new List<SWTag>();
              foreach (JToken tagToken in token.Values())
              {
            // Handle both types of description tags we going to get
            // Sometime its an object, others its an array
            if (tagToken is JArray)
              foreach (JToken innerToken in tagToken)
            result.Add(getTagFromToken(innerToken));
            else
              result.Add(getTagFromToken(tagToken));
              }

              // Sort the tags in desending offset order to aid replacement
              if (result.Count > 0)
            return result.OrderByDescending(x => x.Offset).ToList();
              return null;
        }