using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        byte[] bytes;
        using (var td = new Bitmap(500, 500))
        using (var lgb = new LinearGradientBrush(new Point(0, 0), new Point(td.Width, td.Height), Color.Red, Color.Green))
        using (var g = Graphics.FromImage(td))
        {
            g.FillRectangle(lgb, 0, 0, td.Width, td.Height);

            using (var ms = new MemoryStream())
            {
                td.Save(ms, ImageFormat.Jpeg);
                bytes = ms.ToArray();
            }
        }

        Image img;
        using (var s = new TestStream(bytes))
        {
            img = Image.FromStream(s);
            Console.WriteLine("Image.FromStream");
        }
        img.Save("a.jpg");
        Console.WriteLine("Image.Save");

        Console.ReadKey();
    }
}

internal class TestStream : Stream
{
    private readonly byte[] _Data;
    private int _Position;

    internal TestStream(byte[] array)
    {
        _Data = array;
    }

    public override bool CanRead
    {
        get
        {
            return true;
        }
    }

    public override bool CanSeek
    {
        get
        {
            return true;
        }
    }

    public override bool CanWrite
    {
        get
        {
            return false;
        }
    }

    public override void Flush()
    {
    }

    public override long Length
    {
        get
        {
            return _Data.Length;
        }
    }

    public override long Position
    {
        get
        {
            return _Position;
        }
        set
        {
            _Position = Math.Min(Math.Max(0, (int)value), _Data.Length);
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        var l = Math.Min(count, _Data.Length - _Position);
        if (l <= 0)
        {
            return 0;
        }

        Console.WriteLine("Stream.Read {0}, {1}", _Position, l);

        Array.Copy(_Data, _Position, buffer, offset, l);
        _Position += l;
        return l;
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        switch (origin)
        {
            case SeekOrigin.Begin:
                Position = offset;
                break;
            case SeekOrigin.Current:
                Position += offset;
                break;
            case SeekOrigin.End:
                Position = _Data.Length + offset;
                break;
        }
        return Position;
    }

    public override void SetLength(long value)
    {
        throw new NotSupportedException();
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        throw new NotSupportedException();
    }
}