C# MemoryStream.Write方法代码示例

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] status_bytes = BitConverter.GetBytes(status);
     stream.Write(status_bytes, 0, status_bytes.Length);
     System.Byte[] service_bytes = BitConverter.GetBytes(service);
     stream.Write(service_bytes, 0, service_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] data_bytes = System.Text.Encoding.UTF8.GetBytes(data);
     System.Byte[] data_len_bytes = BitConverter.GetBytes((System.UInt32)data_bytes.Length);
     stream.Write(data_len_bytes, 0, data_len_bytes.Length);
     stream.Write(data_bytes, 0, data_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] name_len_bytes = BitConverter.GetBytes((System.UInt32)name.Count);
     stream.Write(name_len_bytes, 0, name_len_bytes.Length);
     foreach(string element in name)
     {
         System.Byte[] element_bytes = System.Text.Encoding.UTF8.GetBytes(element);
         System.Byte[] element_len_bytes = BitConverter.GetBytes((System.UInt32)element_bytes.Length);
         stream.Write(element_len_bytes, 0, element_len_bytes.Length);
         stream.Write(element_bytes, 0, element_bytes.Length);
     }
     System.Byte[] position_len_bytes = BitConverter.GetBytes((System.UInt32)position.Count);
     stream.Write(position_len_bytes, 0, position_len_bytes.Length);
     foreach(double element in position)
     {
         System.Byte[] element_bytes = BitConverter.GetBytes(element);
         stream.Write(element_bytes, 0, element_bytes.Length);
     }
     System.Byte[] velocity_len_bytes = BitConverter.GetBytes((System.UInt32)velocity.Count);
     stream.Write(velocity_len_bytes, 0, velocity_len_bytes.Length);
     foreach(double element in velocity)
     {
         System.Byte[] element_bytes = BitConverter.GetBytes(element);
         stream.Write(element_bytes, 0, element_bytes.Length);
     }
     System.Byte[] effort_len_bytes = BitConverter.GetBytes((System.UInt32)effort.Count);
     stream.Write(effort_len_bytes, 0, effort_len_bytes.Length);
     foreach(double element in effort)
     {
         System.Byte[] element_bytes = BitConverter.GetBytes(element);
         stream.Write(element_bytes, 0, element_bytes.Length);
     }
 }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] CompressedMessageData_bytes = CompressedMessageData.ToArray();
     System.Byte[] CompressedMessageData_len_bytes = BitConverter.GetBytes((System.UInt32)CompressedMessageData_bytes.Length);
     stream.Write(CompressedMessageData_len_bytes, 0, CompressedMessageData_len_bytes.Length);
     stream.Write(CompressedMessageData_bytes, 0, CompressedMessageData_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] angle_min_bytes = BitConverter.GetBytes(angle_min);
     stream.Write(angle_min_bytes, 0, angle_min_bytes.Length);
     System.Byte[] angle_max_bytes = BitConverter.GetBytes(angle_max);
     stream.Write(angle_max_bytes, 0, angle_max_bytes.Length);
     System.Byte[] angle_increment_bytes = BitConverter.GetBytes(angle_increment);
     stream.Write(angle_increment_bytes, 0, angle_increment_bytes.Length);
     System.Byte[] time_increment_bytes = BitConverter.GetBytes(time_increment);
     stream.Write(time_increment_bytes, 0, time_increment_bytes.Length);
     System.Byte[] scan_time_bytes = BitConverter.GetBytes(scan_time);
     stream.Write(scan_time_bytes, 0, scan_time_bytes.Length);
     System.Byte[] range_min_bytes = BitConverter.GetBytes(range_min);
     stream.Write(range_min_bytes, 0, range_min_bytes.Length);
     System.Byte[] range_max_bytes = BitConverter.GetBytes(range_max);
     stream.Write(range_max_bytes, 0, range_max_bytes.Length);
     System.Byte[] ranges_len_bytes = BitConverter.GetBytes((System.UInt32)ranges.Count);
     stream.Write(ranges_len_bytes, 0, ranges_len_bytes.Length);
     foreach(sensor_msgs.LaserEcho element in ranges)
     {
         element.Serialize(stream);
     }
     System.Byte[] intensities_len_bytes = BitConverter.GetBytes((System.UInt32)intensities.Count);
     stream.Write(intensities_len_bytes, 0, intensities_len_bytes.Length);
     foreach(sensor_msgs.LaserEcho element in intensities)
     {
         element.Serialize(stream);
     }
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] height_bytes = BitConverter.GetBytes(height);
     stream.Write(height_bytes, 0, height_bytes.Length);
     System.Byte[] width_bytes = BitConverter.GetBytes(width);
     stream.Write(width_bytes, 0, width_bytes.Length);
     System.Byte[] fields_len_bytes = BitConverter.GetBytes((System.UInt32)fields.Count);
     stream.Write(fields_len_bytes, 0, fields_len_bytes.Length);
     foreach(sensor_msgs.PointField element in fields)
     {
         element.Serialize(stream);
     }
     System.Byte[] is_bigendian_bytes = BitConverter.GetBytes(is_bigendian);
     stream.Write(is_bigendian_bytes, 0, is_bigendian_bytes.Length);
     System.Byte[] point_step_bytes = BitConverter.GetBytes(point_step);
     stream.Write(point_step_bytes, 0, point_step_bytes.Length);
     System.Byte[] row_step_bytes = BitConverter.GetBytes(row_step);
     stream.Write(row_step_bytes, 0, row_step_bytes.Length);
     System.Byte[] compression_type_bytes = new System.Byte[] {compression_type};
     stream.Write(compression_type_bytes, 0, compression_type_bytes.Length);
     System.Byte[] compressed_data_bytes = compressed_data.ToArray();
     System.Byte[] compressed_data_len_bytes = BitConverter.GetBytes((System.UInt32)compressed_data_bytes.Length);
     stream.Write(compressed_data_len_bytes, 0, compressed_data_len_bytes.Length);
     stream.Write(compressed_data_bytes, 0, compressed_data_bytes.Length);
     System.Byte[] is_dense_bytes = BitConverter.GetBytes(is_dense);
     stream.Write(is_dense_bytes, 0, is_dense_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] Name_bytes = System.Text.Encoding.UTF8.GetBytes(Name);
     System.Byte[] Name_len_bytes = BitConverter.GetBytes((System.UInt32)Name_bytes.Length);
     stream.Write(Name_len_bytes, 0, Name_len_bytes.Length);
     stream.Write(Name_bytes, 0, Name_bytes.Length);
     System.Byte[] UID_bytes = BitConverter.GetBytes(UID);
     stream.Write(UID_bytes, 0, UID_bytes.Length);
     Pose.Serialize(stream);
     Twist.Serialize(stream);
     Skeleton.Serialize(stream);
     System.Byte[] Hands_len_bytes = BitConverter.GetBytes((System.UInt32)Hands.Count);
     stream.Write(Hands_len_bytes, 0, Hands_len_bytes.Length);
     foreach(person_tracker.HandTrack element in Hands)
     {
         element.Serialize(stream);
     }
     System.Byte[] Confidence_bytes = BitConverter.GetBytes(Confidence);
     stream.Write(Confidence_bytes, 0, Confidence_bytes.Length);
     System.Byte[] TrackerType_bytes = new System.Byte[] {TrackerType};
     stream.Write(TrackerType_bytes, 0, TrackerType_bytes.Length);
     System.Byte[] TrackerName_bytes = System.Text.Encoding.UTF8.GetBytes(TrackerName);
     System.Byte[] TrackerName_len_bytes = BitConverter.GetBytes((System.UInt32)TrackerName_bytes.Length);
     stream.Write(TrackerName_len_bytes, 0, TrackerName_len_bytes.Length);
     stream.Write(TrackerName_bytes, 0, TrackerName_bytes.Length);
 }

 private static byte[] GetMultipartFormData(Dictionary<string, object> postParameters, string boundary)
 {
     Stream stream = new MemoryStream();
     bool flag = false;
     foreach (KeyValuePair<string, object> pair in postParameters)
     {
         if (flag)
         {
             stream.Write(encoding.GetBytes("\r\n"), 0, encoding.GetByteCount("\r\n"));
         }
         flag = true;
         if (pair.Value is FileParameter)
         {
             FileParameter parameter = (FileParameter)pair.Value;
             object[] args = new object[] { boundary, pair.Key, parameter.FileName ?? pair.Key, parameter.ContentType ?? "application/octet-stream" };
             string str = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n", args);
             stream.Write(encoding.GetBytes(str), 0, encoding.GetByteCount(str));
             stream.Write(parameter.File, 0, parameter.File.Length);
         }
         else
         {
             string str2 = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}", boundary, pair.Key, pair.Value);
             stream.Write(encoding.GetBytes(str2), 0, encoding.GetByteCount(str2));
         }
     }
     string s = "\r\n--" + boundary + "--\r\n";
     stream.Write(encoding.GetBytes(s), 0, encoding.GetByteCount(s));
     stream.Position = 0L;
     byte[] buffer = new byte[stream.Length];
     stream.Read(buffer, 0, buffer.Length);
     stream.Close();
     return buffer;
 }

    public override void serialize(MemoryStream stream)
    {
        base.serialize(stream);
        byte[] bwdSize =BitConverter.GetBytes(wdSize);
        stream.Write(bwdSize,0,bwdSize.Length);

        stream.Write(sid,0,wdSize);
    }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] relative_humidity_bytes = BitConverter.GetBytes(relative_humidity);
     stream.Write(relative_humidity_bytes, 0, relative_humidity_bytes.Length);
     System.Byte[] variance_bytes = BitConverter.GetBytes(variance);
     stream.Write(variance_bytes, 0, variance_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] temperature_bytes = BitConverter.GetBytes(temperature);
     stream.Write(temperature_bytes, 0, temperature_bytes.Length);
     System.Byte[] variance_bytes = BitConverter.GetBytes(variance);
     stream.Write(variance_bytes, 0, variance_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     stamp.Serialize(stream);
     System.Byte[] id_bytes = System.Text.Encoding.UTF8.GetBytes(id);
     System.Byte[] id_len_bytes = BitConverter.GetBytes((System.UInt32)id_bytes.Length);
     stream.Write(id_len_bytes, 0, id_len_bytes.Length);
     stream.Write(id_bytes, 0, id_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     layout.Serialize(stream);
     System.Byte[] data_bytes = data.ToArray();
     System.Byte[] data_len_bytes = BitConverter.GetBytes((System.UInt32)data_bytes.Length);
     stream.Write(data_len_bytes, 0, data_len_bytes.Length);
     stream.Write(data_bytes, 0, data_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] child_frame_id_bytes = System.Text.Encoding.UTF8.GetBytes(child_frame_id);
     System.Byte[] child_frame_id_len_bytes = BitConverter.GetBytes((System.UInt32)child_frame_id_bytes.Length);
     stream.Write(child_frame_id_len_bytes, 0, child_frame_id_len_bytes.Length);
     stream.Write(child_frame_id_bytes, 0, child_frame_id_bytes.Length);
     transform.Serialize(stream);
 }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] type_bytes = new System.Byte[] {type};
     stream.Write(type_bytes, 0, type_bytes.Length);
     System.Byte[] id_bytes = new System.Byte[] {id};
     stream.Write(id_bytes, 0, id_bytes.Length);
     System.Byte[] intensity_bytes = BitConverter.GetBytes(intensity);
     stream.Write(intensity_bytes, 0, intensity_bytes.Length);
 }