C# JToken.WriteTo方法代码示例

        byte[] CompressJson(JToken rpJsonToken)
        {
            using (var rMemoryStream = new MemoryStream())
            {
                using (var rCompressStream = new DeflateStream(rMemoryStream, CompressionMode.Compress))
                using (var rStreamWriter = new StreamWriter(rCompressStream))
                using (var rJsonTextWriter = new JsonTextWriter(rStreamWriter))
                    rpJsonToken.WriteTo(rJsonTextWriter);

                return rMemoryStream.ToArray();
            }
        }

 protected static void WriteValue(JsonWriter writer, JToken value) {
     writer.WritePropertyName("value");
     value.WriteTo(writer);
 }

        static void SaveBlob(string storageConnectionString, string name, JToken content)
        {
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
            CloudBlobClient client = storageAccount.CreateCloudBlobClient();
            CloudBlobContainer container = client.GetContainerReference("nuget");
            CloudBlockBlob blob = container.GetBlockBlobReference(name);

            blob.Properties.ContentType = "application/json";
            blob.Properties.CacheControl = "no-cache";

            MemoryStream stream = new MemoryStream();
            StreamWriter writer = new StreamWriter(stream);
            using (JsonWriter jsonWriter = new JsonTextWriter(writer))
            {
                jsonWriter.Formatting = Formatting.Indented;

                content.WriteTo(jsonWriter);
                jsonWriter.Flush();
                writer.Flush();
                stream.Seek(0, SeekOrigin.Begin);
                blob.UploadFromStream(stream);
            }

            //Console.WriteLine(name);
        }

        public async Task<bool> SaveJTokenToTextFile(JToken token, string fileName)
        {
            if (string.IsNullOrWhiteSpace(fileName))
            {
                //throw new ArgumentNullException(nameof(fileName));
                return true;
            }
            try
            {
                // Write to file
                var path = fileName;
                if (!Path.IsPathRooted(path))
                {
                    //path = Path.Combine(Environment.CurrentDirectory, path);
                    path = PathHelper.Combine(Environment.CurrentDirectory, path);
                }
                //var dir = new DirectoryInfo(Path.GetDirectoryName(path));
                var dir = new DirectoryInfo(PathHelper.GetParent(path));
                if (!dir.Exists)
                    dir.Create();

                var exists = File.Exists(path);
                using (var stream = File.Open(path, exists ? FileMode.Truncate : FileMode.CreateNew, FileAccess.Write))
                {
                    var wr = new StreamWriter(stream);
                    var jw = new JsonTextWriter(wr)
                    {
                        Formatting = Formatting.Indented,
                    };
                    JsonConverter[] converters = new JsonConverter[0];
                    token.WriteTo(jw, converters);
                    await wr.FlushAsync();
                }
                System.Console.WriteLine("File saved: " + path);
                return true;
            }
            catch (Exception ex)
            {
                throw;
            }
            return false;
        }

		private void Write(JToken token)
		{
			if(token == null)
			{
				binaryWriter.Write((byte)JTokenType.Null);
				return;
			}
			binaryWriter.Write((byte)token.Type);
			switch (token.Type)
			{
				case JTokenType.None:
				case JTokenType.Constructor:
				case JTokenType.Comment:
				case JTokenType.Raw:
				case JTokenType.Property:
					throw new NotSupportedException("Can't write " + token);
				case JTokenType.Object:
				case JTokenType.Array:
					token.WriteTo(new BsonWriter(writer));
					break;
				case JTokenType.Integer:
					binaryWriter.Write(token.Value<int>());
					break;
				case JTokenType.Float:
					binaryWriter.Write(token.Value<float>());
					break;
				case JTokenType.String:
					binaryWriter.Write(token.Value<string>());
					break;
				case JTokenType.Boolean:
					binaryWriter.Write(token.Value<bool>());
					break;
				case JTokenType.Null:
				case JTokenType.Undefined:
					break;
				case JTokenType.Date:
					binaryWriter.Write(token.Value<DateTime>().ToBinary());
					break;
				case JTokenType.Bytes:
					var buffer = token.Value<byte[]>();
					binaryWriter.Write(buffer.Length);
					binaryWriter.Write(buffer);
					break;
				default:
					throw new ArgumentOutOfRangeException();
			}
		}

	public void cb1 (JToken obj, string graph_path, fbdump_params p)
	{
		if (obj.Type == JTokenType.Object) {
			JObject obj1 = (JObject)obj;
			string id = obj1 ["id"].Value<string> ();
			try {
				string fn = saveto + "/" + id;
				if (System.IO.File.Exists (fn))
					p.exists++;
				System.IO.FileStream fs = new System.IO.FileStream (fn, p.stop_on_existing ? FileMode.CreateNew : FileMode.Create);
				JsonWriter w = new JsonTextWriter (new StreamWriter (fs));
				obj.WriteTo (w);
				w.CloseOutput = true;
				w.Close ();
				if (graph_path != null) {
					string n = graph_path.Trim ('/').Replace ('/', '.');
					Mono.Unix.UnixSymbolicLinkInfo inf = new Mono.Unix.UnixSymbolicLinkInfo (saveto + "/" + n + "/" + id);
					inf.CreateSymbolicLinkTo ("../" + id);
				}
				foreach (JProperty pr in obj1.Properties()) {
					if (p.saveurl.Contains (pr.Name)) {
						saveurl (pr.Value.Value<string> (), id + "." + pr.Name);
					}
				}
			} catch (Exception ex) {
				Console.WriteLine (ex.Message);
				if (p.stop_on_existing) {
					stop ();
				}
			}
		}
	}