Represents a writer that provides a fast, non-cached, forward-only way of generating JSON data.
Inheritance: JsonWriter
コード例 #1
0
    public void WriteValues()
    {
      MemoryStream ms = new MemoryStream();
      BsonWriter writer = new BsonWriter(ms);

      writer.WriteStartArray();
      writer.WriteValue(long.MaxValue);
      writer.WriteValue((ulong)long.MaxValue);
      writer.WriteValue(int.MaxValue);
      writer.WriteValue((uint)int.MaxValue);
      writer.WriteValue(byte.MaxValue);
      writer.WriteValue(sbyte.MaxValue);
      writer.WriteValue('a');
      writer.WriteValue(decimal.MaxValue);
      writer.WriteValue(double.MaxValue);
      writer.WriteValue(float.MaxValue);
      writer.WriteValue(true);
      writer.WriteValue(new byte[] { 0, 1, 2, 3, 4 });
      writer.WriteValue(new DateTimeOffset(2000, 12, 29, 12, 30, 0, TimeSpan.Zero));
      writer.WriteValue(new DateTime(2000, 12, 29, 12, 30, 0, DateTimeKind.Utc));
      writer.WriteEnd();

      string bson = MiscellaneousUtils.BytesToHex(ms.ToArray());
      Assert.AreEqual("8C-00-00-00-12-30-00-FF-FF-FF-FF-FF-FF-FF-7F-12-31-00-FF-FF-FF-FF-FF-FF-FF-7F-10-32-00-FF-FF-FF-7F-10-33-00-FF-FF-FF-7F-10-34-00-FF-00-00-00-10-35-00-7F-00-00-00-02-36-00-02-00-00-00-61-00-01-37-00-00-00-00-00-00-00-F0-45-01-38-00-FF-FF-FF-FF-FF-FF-EF-7F-01-39-00-00-00-00-E0-FF-FF-EF-47-08-31-30-00-01-05-31-31-00-05-00-00-00-02-00-01-02-03-04-09-31-32-00-40-C5-E2-BA-E3-00-00-00-09-31-33-00-40-C5-E2-BA-E3-00-00-00-00", bson);
    }
コード例 #2
0
        /// <inheritdoc />
        public override Task ExecuteResultAsync(ActionContext context)
        {
            var response = context.HttpContext.Response;

            response.ContentType = ContentType.Bson;

            if (StatusCode != null)
            {
                response.StatusCode = StatusCode.Value;
            }

            var serializerSettings = _serializerSettings;
            if (serializerSettings == null)
            {
                serializerSettings = context
                    .HttpContext
                    .RequestServices
                    .GetRequiredService<IOptions<MvcJsonOptions>>()
                    .Value
                    .SerializerSettings;
            }

            using (var bsonWriter = new BsonWriter(response.Body))
            {
                bsonWriter.CloseOutput = false;
                var jsonSerializer = JsonSerializer.Create(serializerSettings);
                jsonSerializer.Serialize(bsonWriter, Value);
            }

            return Task.FromResult(true);
        }
コード例 #3
0
 public void Export(Stream stream)
 {
     using (BsonWriter writer = new BsonWriter(stream))
     {
         _jsonSerializer.Serialize(writer, _cardsByID);
     }
 }
コード例 #4
0
        public static async Task<byte[]> PackFileTransferMessageAsync(SongTransferMessage message)
        {
            byte[] serialized;

            using (var ms = new MemoryStream())
            {
                using (var writer = new BsonWriter(ms))
                {
                    var serializer = new JsonSerializer();

                    await Task.Run(() => serializer.Serialize(writer, message));
                }

                // Don't return earlier here, we don't know of the BsonWriter is finished.
                serialized = ms.ToArray();
            }

            byte[] length = BitConverter.GetBytes(serialized.Length); // We have a fixed size of 4 bytes

            var returnData = new byte[length.Length + serialized.Length];

            // We could simply call .ToArray() everywhere, but with Buffer.BlockCopy, we are
            // reducing memory pressure and CPU time on mobile devices by an order of magnitude
            Buffer.BlockCopy(length, 0, returnData, 0, length.Length);
            Buffer.BlockCopy(serialized, 0, returnData, length.Length, serialized.Length);

            return returnData;
        }
コード例 #5
0
ファイル: ThreadProcess.cs プロジェクト: intech/Checker
        public bool SendCmdRequest(CmdRequest request)
        {
            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                socket.Connect("127.0.0.1", Port);
                using (NetworkStream stream = new NetworkStream(socket))
                {
                    using (BsonWriter writer = new BsonWriter(stream))
                    {
                        JsonSerializer serializer = new JsonSerializer();
                        serializer.Serialize(writer, request);
                        writer.Flush();
                        writer.Close();
                    }
                   
                    stream.Close();
                }
            }
            catch(Exception ex)
            {
                Logger.AddError(string.Format("Failed to send cmd request to checker with port = {0}", Port), ex);
                return false;
            }

            return true;
        }
コード例 #6
0
        public void DateTimeKindHandling()
        {
            DateTime value = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);

              MemoryStream ms = new MemoryStream();
              BsonWriter writer = new BsonWriter(ms);

              writer.WriteStartObject();
              writer.WritePropertyName("DateTime");
              writer.WriteValue(value);
              writer.WriteEndObject();

              byte[] bson = ms.ToArray();

              JObject o;
              BsonReader reader;

              reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Utc);
              o = (JObject)JToken.ReadFrom(reader);
              Assert.AreEqual(value, (DateTime)o["DateTime"]);

              reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Local);
              o = (JObject)JToken.ReadFrom(reader);
              Assert.AreEqual(value.ToLocalTime(), (DateTime)o["DateTime"]);

              reader = new BsonReader(new MemoryStream(bson), false, DateTimeKind.Unspecified);
              o = (JObject)JToken.ReadFrom(reader);
              Assert.AreEqual(DateTime.SpecifyKind(value.ToLocalTime(), DateTimeKind.Unspecified), (DateTime)o["DateTime"]);
        }
コード例 #7
0
        protected override void OnWriteToStream(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext context)
        {

            var serializer = new JsonSerializer { ReferenceLoopHandling = ReferenceLoopHandling.Ignore };
            // NOTE: we don't dispose or close these as they would 
            // close the stream, which is used by the rest of the pipeline.
            var writer = default(JsonWriter);

            if (contentHeaders.ContentType.MediaType == "application/bson")
                writer = new BsonWriter(stream);
            else
                writer = new JsonTextWriter(new StreamWriter(stream));

            if (UsesQueryComposition)
            {
                serializer.Serialize(writer, ((IEnumerable)value).OfType<object>().ToList());
            }
            else
            {
                serializer.Serialize(writer, value);
            }

            writer.Flush();

        }
コード例 #8
0
ファイル: JsonNetSpike.cs プロジェクト: ngbrown/EasyNetQ
        public void UseBsonSerializer()
        {
            var message = GetMyJsonTestMessage();

            var serializer = new JsonSerializer();
            byte[] serializedMessage;

            using (var stream = new MemoryStream())
            using (var writer = new BsonWriter(stream))
            {
                serializer.Serialize(writer, message);

                serializedMessage = stream.GetBuffer();
            }

            MyJsonTestMessage deserializedMessage;
            using (var stream = new MemoryStream(serializedMessage))
            using (var reader = new BsonReader(stream))
            {

                deserializedMessage = serializer.Deserialize<MyJsonTestMessage>(reader);
            }

            Console.Out.WriteLine(deserializedMessage.GetHashCode() == message.GetHashCode());
        }
コード例 #9
0
 public override void Serialize(Stream stream, object instance)
 {
     using (var writer = new BsonWriter(stream))
     {
         base.Serialize(writer, instance);
     }
 }
コード例 #10
0
 public static void Serialize(Stream stream, object instance)
 {
     using (var writer = new BsonWriter(stream))
     {
         serializer.Serialize(writer, instance);
     }
 }
コード例 #11
0
ファイル: BsonFormatter.cs プロジェクト: sergiosilvajr/mpos
		public static byte[] Serialize(object[] methodParams)
		{
			List<String> complexParams = new List<String>();
			object[] payload = new object[methodParams.Length + 1];

			//elements
			int count = 1;
			foreach (object param in methodParams)
			{
				payload[count] = param;
				complexParams.Add(param.GetType().FullName);
				count++;
			}

			//header type
			payload[0] = complexParams;

			using (MemoryStream memoryStream = new MemoryStream(4096))
			{
				using (BsonWriter bsonWriter = new BsonWriter(memoryStream))
				{
					BsonObject bson = new BsonObject();
					bson.Payload = payload;

					JsonSerializer serializer = new JsonSerializer();
					serializer.Serialize(bsonWriter, bson);
				}
				return memoryStream.ToArray();
			}
		}
コード例 #12
0
    private void WriteBson(BsonWriter writer, Regex regex)
    {
      // Regular expression - The first cstring is the regex pattern, the second
      // is the regex options string. Options are identified by characters, which 
      // must be stored in alphabetical order. Valid options are 'i' for case 
      // insensitive matching, 'm' for multiline matching, 'x' for verbose mode, 
      // 'l' to make \w, \W, etc. locale dependent, 's' for dotall mode 
      // ('.' matches everything), and 'u' to make \w, \W, etc. match unicode.

      string options = null;

      if (HasFlag(regex.Options, RegexOptions.IgnoreCase))
        options += "i";

      if (HasFlag(regex.Options, RegexOptions.Multiline))
        options += "m";

      if (HasFlag(regex.Options, RegexOptions.Singleline))
        options += "s";

      options += "u";

      if (HasFlag(regex.Options, RegexOptions.ExplicitCapture))
        options += "x";

      writer.WriteRegex(regex.ToString(), options);
    }
コード例 #13
0
 protected override void OnWriteToStream(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext context)
 {
     var serializer = new JsonSerializer();
     using (var writer = new BsonWriter(stream.PreventClose())) {
         serializer.Serialize(writer, value);
         writer.Flush();
     }
 }
コード例 #14
0
 /// <summary>
 /// Called during serialization to create the <see cref="BsonWriter"/>.
 /// </summary>
 /// <param name="stream">The <see cref="Stream"/> to write to.</param>
 /// <returns>The <see cref="BsonWriter"/> used during serialization.</returns>
 protected virtual BsonWriter CreateBsonWriter(Stream stream)
 {
     var bsonWriter = new BsonWriter(stream)
     {
         CloseOutput = false
     };
     return bsonWriter;
 }
コード例 #15
0
		public override void Serialize(Stream output, object graph)
		{
			if (graph == null)
				return;

			var writer = new BsonWriter(output) { DateTimeKindHandling = DateTimeKind.Utc };
			this.Serialize(writer, graph);
		}
コード例 #16
0
 public static void Write(FileStream stream, object value)
 {
     using (var bw = new Newtonsoft.Json.Bson.BsonWriter(stream))
     {
         var serializer = new Newtonsoft.Json.JsonSerializer();
         serializer.Serialize(bw, value);
     }
 }
コード例 #17
0
        public void PerformBinarySerialisation(System.IO.Stream outputStream, object graph, string jsCallbackName)
        {
            //MemoryStream ms = new MemoryStream();
            JsonSerializer serializer = new JsonSerializer();

            // serialize product to BSON
            BsonWriter writer = new BsonWriter(outputStream);
            serializer.Serialize(writer, graph);
        }
コード例 #18
0
 public virtual byte[] Serialize(object obj)
 {
     using (var outStream = new MemoryStream())
     using (var bsonWriter = new BsonWriter(outStream))
     {
         CreateSerializer().Serialize(bsonWriter, obj);
         return outStream.ToArray();
     }
 }
コード例 #19
0
ファイル: DefaultSerializer.cs プロジェクト: promontis/Even
 private static byte[] SerializeInternal(object o)
 {
     using (var ms = new MemoryStream())
     using (var writer = new BsonWriter(ms))
     {
         var serializer = new JsonSerializer();
         serializer.Serialize(writer, o);
         return ms.ToArray();
     }
 }
コード例 #20
0
        public void Serialize(Stream s, object item)
        {
            //Condition.Requires(s, "s").IsNotNull();
              //Condition.Requires(item, "item").IsNotNull();

              using (var w = new BsonWriter(s))
              {
            Serializer.Serialize(w, item);
              }
        }
コード例 #21
0
 protected virtual byte[] Serialize(object obj)
 {
     using (var ms = new MemoryStream())
     {
         var bw = new BsonWriter(ms);
         Serializer.Serialize(bw, obj);
         bw.Close();
         return ms.ToArray();
     }
 }
コード例 #22
0
        public void Execute(ClientInformation client, Stream clientStream)
        {
            using (var reader = new BsonReader(clientStream))
            using (var writer = new BsonWriter(clientStream))
            {
                try
                {
                    Log.Info("Deserializing JSON-RPC request");

                    var request = serializer.Deserialize<JsonRpcRequest>(reader);
                    if (request == null) throw new ArgumentException("No JSON-RPC request was sent");

                    var activityName = string.Format("{0} : {1}", client.RemoteAddress, request.Id);
                    using (Log.BeginActivity(activityName, request.ActivityId))
                    {
                        try
                        {
                            Log.Info("Validating request");

                            if (string.IsNullOrWhiteSpace(request.Service)) throw new ArgumentException("No service name was specified in the JSON-RPC request");
                            if (string.IsNullOrWhiteSpace(request.Method)) throw new ArgumentException("No service method was specified in the JSON-RPC request");

                            Log.InfoFormat("Resolving service {0}", request.Service);

                            var serviceType = services.GetService(request.Service);
                            if (serviceType == null)
                            {
                                throw new ArgumentException(string.Format("The service type {0} is not implemented on this server", request.Service));
                            }

                            Log.InfoFormat("Constructing service {0}", serviceType.FullName);

                            JsonRpcResponse response;
                            using (var lease = serviceFactory.CreateService(serviceType))
                            {
                                var service = lease.Service;

                                response = serviceInvoker.Invoke(service, request);
                            }

                            SendResponse(writer, response);
                        }
                        catch (Exception ex)
                        {
                            SendResponse(writer, CreateError(ex, request));
                        }
                    }
                }
                catch (Exception ex)
                {
                    SendResponse(writer, CreateError(ex, null));
                }
            }
        }
コード例 #23
0
 public byte[] Serialize(object item)
 {
     using (var s = new MemoryStream())
       {
     using (var w = new BsonWriter(s))
     {
       Serializer.Serialize(w, item);
     }
     return s.ToArray();
       }
 }
コード例 #24
0
        /// <summary>
        /// Saves a user to the file.
        /// </summary>
        /// <param name="user">The user to be saved.</param>
        public async void SaveUser(User user)
        {
            StorageFolder local = Windows.Storage.ApplicationData.Current.LocalFolder;
            var file = await local.CreateFileAsync("user", CreationCollisionOption.ReplaceExisting);

            var fileStream = await file.OpenStreamForWriteAsync();
            using (var writer = new BsonWriter(new BinaryWriter(fileStream)))
            {
                var serializer = new JsonSerializer();
                serializer.Serialize(writer, user);
            }
        }
コード例 #25
0
 private static long WriteNewtonsoftBson(string path)
 {
     FileStream fs = File.OpenWrite(path);
     using (var bsonWriter = new BsonWriter(fs) { CloseOutput = false })
     {
         var jsonSerializer = new JsonSerializer();
         jsonSerializer.Serialize(bsonWriter, GetTestObjects());
         bsonWriter.Flush();
     }
     fs.Close();
     return new FileInfo(path).Length;
 }
コード例 #26
0
 public static byte[] GetBytes(this StoredEvent<JObject> storedEvent)
 {
     var output = new MemoryStream();
     var writer = new BinaryWriter(output);
     writer.Write(storedEvent.EventIdentifier.ToByteArray());
     writer.Write(storedEvent.EventTimeStamp.Ticks);
     writer.Write(storedEvent.EventName);
     writer.Write(storedEvent.EventVersion.ToString());
     var bsonWriter = new BsonWriter(output);
     storedEvent.Data.WriteTo(bsonWriter);
     return output.ToArray();
 }
コード例 #27
0
        static byte[] BSON(object data)
        {
            var stream = new System.IO.MemoryStream();

            using (var writer = new BsonWriter(stream))
            {
                var serializer = new JsonSerializer();
                serializer.Serialize(writer, data);
            }

            return stream.ToArray();
        }
コード例 #28
0
ファイル: RavenMQPublisher.cs プロジェクト: nieve/ravenmq
 public IRavenMQPublisher Add(string queue, object msg, JObject metadata)
 {
     var memoryStream = new MemoryStream();
     using(var bsonWriter = new BsonWriter(memoryStream))
         ToJson(msg).WriteTo(bsonWriter);
     return AddRaw(new IncomingMessage
     {
         Data = memoryStream.ToArray(),
         Metadata = metadata,
         Queue = queue,
     });
 }
コード例 #29
0
ファイル: Util.cs プロジェクト: ReginaBricker/Voron.Graph
        internal static Stream ToStream(this JObject jsonObject)
        {
            if (jsonObject == null)
                return Stream.Null;

            var stream = new MemoryStream();
            var writer = new BsonWriter(stream);
            jsonObject.WriteTo(writer);

            stream.Position = 0;
            return stream;
        }      
コード例 #30
0
        public void WriteSingleObject()
        {
            MemoryStream ms = new MemoryStream();
            BsonWriter writer = new BsonWriter(ms);

            writer.WriteStartObject();
            writer.WritePropertyName("Blah");
            writer.WriteValue(1);
            writer.WriteEndObject();

            string bson = BytesToHex(ms.ToArray());
            Assert.AreEqual("0F-00-00-00-10-42-6C-61-68-00-01-00-00-00-00", bson);
        }
コード例 #31
0
ファイル: Serializer.cs プロジェクト: jamesholcomb/NDomain
        public static Stream Serialize(JObject obj)
        {
            var stream = new MemoryStream();
            using (var jsonWriter = new BsonWriter(stream))
            {
                jsonWriter.CloseOutput = false;
                obj.WriteTo(jsonWriter);
            }

            stream.Position = 0;

            return stream;
        }