System.IO.Stream.WriteAny(object)

Here are the examples of the csharp api System.IO.Stream.WriteAny(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1 Examples 7

19 Source : StreamEncodingExtensions.cs
with MIT License
from yjs

[MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void WriteAny(this Stream stream, object o)
        {
            switch (o)
            {
                case string str: // TYPE 119: STRING
                    stream.WriteByte(119);
                    stream.WriteVarString(str);
                    break;
                case bool b: // TYPE 120/121: boolean (true/false)
                    stream.WriteByte((byte)(b ? 120 : 121));
                    break;
                case double d: // TYPE 123: FLOAT64
#if NETSTANDARD2_0
                    var dBytes = BitConverter.GetBytes(d);
                    if (BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(dBytes);
                    }
                    stream.WriteByte(123);
                    stream.Write(dBytes, 0, dBytes.Length);
                    break;
#elif NETSTANDARD2_1
                    Span<byte> dBytes = stackalloc byte[8];
                    if (!BitConverter.TryWriteBytes(dBytes, d))
                    {
                        throw new InvalidDataException("Unable to write a double value.");
                    }
                    if (BitConverter.IsLittleEndian)
                    {
                        dBytes.Reverse();
                    }
                    stream.WriteByte(123);
                    stream.Write(dBytes);
                    break;
#endif // NETSTANDARD2_0
                case float f: // TYPE 124: FLOAT32
#if NETSTANDARD2_0
                    var fBytes = BitConverter.GetBytes(f);
                    if (BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(fBytes);
                    }
                    stream.WriteByte(124);
                    stream.Write(fBytes, 0, fBytes.Length);
                    break;
#elif NETSTANDARD2_1
                    Span<byte> fBytes = stackalloc byte[4];
                    if (!BitConverter.TryWriteBytes(fBytes, f))
                    {
                        throw new InvalidDataException("Unable to write a float value.");
                    }
                    if (BitConverter.IsLittleEndian)
                    {
                        fBytes.Reverse();
                    }
                    stream.WriteByte(124);
                    stream.Write(fBytes);
                    break;
#endif // NETSTANDARD2_0
                case int i: // TYPE 125: INTEGER
                    stream.WriteByte(125);
                    stream.WriteVarInt(i);
                    break;
                case long l: // Special case: treat LONG as INTEGER.
                    stream.WriteByte(125);
                    stream.WriteVarInt(l);
                    break;
                case null: // TYPE 126: null
                           // TYPE 127: undefined
                    stream.WriteByte(126);
                    break;
                case byte[] ba: // TYPE 116: ArrayBuffer
                    stream.WriteByte(116);
                    stream.WriteVarUint8Array(ba);
                    break;
                case IDictionary dict: // TYPE 118: object (Dictionary<string, object>)
                    stream.WriteByte(118);
                    stream.WriteVarUint((uint)dict.Count);
                    foreach (var key in dict.Keys)
                    {
                        stream.WriteVarString(key.ToString());
                        stream.WriteAny(dict[key]);
                    }
                    break;
                case ICollection col: // TYPE 117: Array
                    stream.WriteByte(117);
                    stream.WriteVarUint((uint)col.Count);
                    foreach (var item in col)
                    {
                        stream.WriteAny(item);
                    }
                    break;
                default:
                    throw new NotSupportedException($"Unsupported object type: {o?.GetType()}");
            }
        }