namespace WinFormSamples
{
 using System;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
 using BruTile;
 using BruTile.Cache;

 using GeoAPI.Geometries;

 using SharpMap;
 using SharpMap.Layers;

 internal class SharpMapTileSource : ITileSource
 {
 private readonly SharpMapTileProvider provider;

 public SharpMapTileSource(ITileSchema schema, params ILayer[] layers) : this(schema, null, layers) { }

 public SharpMapTileSource(ITileSchema schema, ITileCache<byte[]> cache, params ILayer[] layers)
 {
 Title = "SharpMap.Map";
 if (schema == null)
 throw new ArgumentNullException("schema");
 if (layers == null)
 throw new ArgumentNullException("layers");

 this.provider = new SharpMapTileProvider(schema, cache, layers);
 }

 public string Title { get; set; }

 public ITileProvider Provider
 {
 get { return this.provider; }
 }

 public ITileSchema Schema
 {
 get { return this.provider.Schema; }
 }

 public string Name { get; private set; }

 public Extent Extent
 {
 get { throw new NotImplementedException(); }
 }

 public Attribution Attribution => throw new NotImplementedException();

 public byte[] GetTile(TileInfo tileInfo)
 {
 return provider.GetTile(tileInfo);
 }
 }

 internal class SharpMapTileProvider : ITileProvider
 {
 private class NullCache : ITileCache<byte[]>
 {
 public void Add(TileIndex index, byte[] image) { }

 public void Remove(TileIndex index) { throw new NotImplementedException(); }

 public byte[] Find(TileIndex index) { return null; }
 }

 private readonly ITileCache<byte[]> cache;

 public ITileSchema Schema { get; private set; }

 private readonly LayerCollection layers;

 private ImageFormat format;

 public SharpMapTileProvider(ITileSchema schema, ITileCache<byte[]> cache, params ILayer[] layers)
 { 
 if (schema == null)
 throw new ArgumentNullException("schema");
 if (layers == null)
 throw new ArgumentNullException("layers");
 
 this.Schema = schema;
 this.cache = cache ?? new NullCache();

 LayerCollection collection = new LayerCollection();
 foreach (ILayer layer in layers)
 collection.Add(layer);
 this.layers = collection;
 }

 public byte[] GetTile(TileInfo info)
 {
 if (info == null)
 throw new ArgumentNullException("info");

 if (this.format == null)
 this.format = GetFormat(this.Schema);

 TileIndex index = info.Index;
 byte[] bytes = this.cache.Find(index);
 if (bytes != null)
 return bytes; 

 using (Image tile = this.CreateTile(info))
 using (MemoryStream ms = new MemoryStream())
 { 
 tile.Save(ms, this.format);
 bytes = ms.ToArray();
 this.cache.Add(index, bytes);
 return ms.ToArray();
 }
 }

 private static ImageFormat GetFormat(ITileSchema schema)
 {
 string format = schema.Format;
 if (String.Equals("JPEG", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Jpeg;
 if (String.Equals("JPG", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Jpeg;
 if (String.Equals("GIF", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Gif;
 if (String.Equals("BMP", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Bmp;
 if (String.Equals("TIFF", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Tiff;
 if (String.Equals("TIF", format, StringComparison.InvariantCultureIgnoreCase))
 return ImageFormat.Tiff;
 return ImageFormat.Png;
 }

 private readonly object synclock = new object();

 private Image CreateTile(TileInfo info) 
 {
 lock (synclock)
 {
 var tileWidth = this.Schema.GetTileWidth(info.Index.Level);
 var tileHeight = this.Schema.GetTileHeight(info.Index.Level);
 Size size = new Size(tileWidth, tileHeight);
 Map map = new Map(size) { BackColor = Color.Transparent };
 map.Layers.AddCollection(this.layers);

 Extent ext = info.Extent;
 Envelope bbox = new Envelope(ext.MinX, ext.MaxX, ext.MinY, ext.MaxY);
 map.ZoomToBox(bbox);

 return map.GetMap();
 }
 }
 } 
}