protected override string CreateRequestUriCore(TileIndex index)
		{
			int z = (int)index.Level;
			int shift = MapTileProvider.GetSideTilesCount(z) / 2;
			int x = index.X + shift;
			int y = MapTileProvider.GetSideTilesCount(z) - 1 - index.Y - shift;

			char serverIdx = (char)('a' + CurrentServer);
			string uri = "";
			switch (renderer)
			{
				case OpenStreetMapRenderer.Mapnik:
					uri = "tile.openstreetmap.org";
					break;
				case OpenStreetMapRenderer.Osmarenderer:
					uri = "tah.openstreetmap.org/Tiles/tile";
					break;
				case OpenStreetMapRenderer.CycleMap:
					uri = "andy.sandbox.cloudmade.com/tiles/cycle";
					break;
				case OpenStreetMapRenderer.NoName:
					uri = "tile.cloudmade.com/fd093e52f0965d46bb1c6c6281022199/3/256";
					break;
				default:
					break;
			}

			return String.Format(UriFormat, z.ToString(), x.ToString(), y.ToString(), serverIdx.ToString(), uri);
		}

		public BitmapImage this[TileIndex id]
		{
			get
			{
				return cache[id];
			}
		}

		public BitmapSource this[TileIndex id]
		{
			get
			{
				return (BitmapSource)cache[id].Target;
			}
		}

		public override void BeginLoadImage(TileIndex id)
		{
			if (Contains(id))
				ReportSuccess(cache[id], id);
			else
				ReportFailure(id);
		}

		protected sealed override string CreateRequestUriCore(TileIndex index)
		{
			string indexString = CreateTileIndexString(index);

			string res = String.Format(UriFormat, CurrentServer, indexString);
			return res;
		}

		public void BeginSaveImage(TileIndex id, BitmapImage image)
		{
			string imagePath = GetImagePath(id);

			bool errorWhileDeleting = false;

			bool containsOld = Contains(id);
			if (containsOld && saveOption == SaveOption.ForceUpdate)
				try
				{
					File.Delete(imagePath);
				}
				catch (IOException exc)
				{
					// todo возможно, тут добавить файл в очередь на удаление или перезапись новым содержимым
					// когда он перестанет быть блокированным
					Debug.WriteLine(String.Format("{0} - error while deleting tile {1}: {2}", Name, id, exc.Message));
					errorWhileDeleting = true;
				}

			bool shouldSave = saveOption == SaveOption.ForceUpdate && !errorWhileDeleting ||
				saveOption == SaveOption.PreserveOld && !containsOld;
			if (shouldSave)
			{
				Debug.WriteLine("Began to save id = " + id);

				Statistics.IntValues["ImagesSaved"]++;

				ImageSaver saver = ScreenshotHelper.SaveBitmapToFile;
				saver.BeginInvoke((BitmapImage)image.GetAsFrozen(), imagePath, null, null);
			}
		}

		public override void BeginLoadImage(TileIndex id)
		{
			if (CanLoadFast(id))
				resourceServer.BeginLoadImage(id);
			else
				base.BeginLoadImage(id);
		}

        protected void BeginLoadBitmapImpl(Stream stream, TileIndex id)
        {
            Dispatcher.BeginInvoke((Action)(() =>
            {
                BitmapImage bmp = new BitmapImage();
                SubscribeBitmapEvents(bmp);
                pendingBitmaps.Add(bmp, id);

                MemoryStream memStream = new MemoryStream();
                stream.CopyTo(memStream);
                memStream.Seek(0, SeekOrigin.Begin);
                stream.Dispose();

                bmp.BeginInit();
                bmp.StreamSource = memStream;
                bmp.CacheOption = BitmapCacheOption.OnLoad;
                bmp.EndInit();

                if (!bmp.IsDownloading)
                {
                    UnsubscribeBitmapEvents(bmp);
                    ReportSuccess(memStream, bmp, id);
                    pendingBitmaps.Remove(bmp);
                    bmp.Freeze();
                }
            }));
        }

		protected override string CreateRequestUriCore(TileIndex index)
		{
			int level = (int)index.Level;
			int x = index.X;
			int y = index.Y;

			return String.Format(UriFormat, level.ToString(), x.ToString(), y.ToString());
		}

		public void BeginSaveImage(TileIndex id, BitmapSource image, Stream stream)
		{
            if (image == null)
                throw new ArgumentNullException("image");

			cache[id] = new WeakReference(image);
			Statistics.IntValues["ImagesSaved"]++;
		}

		protected override string CreateRequestUriCore(TileIndex index)
		{
			int level = (int)index.Level;
            var y = MapTileProvider.GetSideTilesCount(level) / 2 + index.Y;
            var x = MapTileProvider.GetSideTilesCount(level) / 2 + index.X;
			string uri = String.Format(UriFormat, CurrentServer, level, x, y);
			return uri;
		}

		protected override string CreateRequestUri(TileIndex index)
		{
			int z = index.Level;
			int x = index.X;
			int y = MapTileProvider.GetSideTilesNum(z) - 1 - index.Y;

			return String.Format(UriFormat, z, x, y);
		}

		public override bool Contains(TileIndex id)
		{
			if (!metadataRequestSent)
			{
				SendMetadataRequest();
			}
			return loaded && base.Contains(id);
		}

		private string CreateResourceName(TileIndex id)
		{
			StringBuilder builder = new StringBuilder(currentPrefix);
			builder = builder.Append(id.Level).Append(".").Append(id.X).Append("x")
				.Append(id.Y).Append(fileExtension);

			return builder.ToString();
		}

		public override string GetTilePath(TileIndex id)
		{
			StringBuilder builder = new StringBuilder("z");

			builder = builder.Append(id.Level).Append(Path.DirectorySeparatorChar).Append(id.X).Append('x').Append(id.Y);

			return builder.ToString();
		}

		public override bool Contains(TileIndex id)
		{
			string path = pathProvider.GetTilePath(id) + extension;
			Uri uri = GetPartUri(path);

			bool exists = package.PartExists(uri);
			return exists;
		}

		protected override void ReportFailure(TileIndex id)
		{
			runningDownloadsNum--;

			BeginLoadImageFromQueue();

			base.ReportFailure(id);
		}

		protected override string CreateRequestUriCore(TileIndex index)
		{
			int x = index.X;
			int y = MapTileProvider.GetSideTilesCount(index.Level) - 1 - index.Y;
			int z = (int)index.Level;
			string uri = String.Format(UriFormat, x, y, z);
			return uri;
		}

        public void BeginSaveImage(TileIndex id, BitmapSource image, Stream stream)
        {
            string imagePath = GetImagePath(id);

            bool errorWhileDeleting = false;

            bool containsOld = Contains(id);
            if (containsOld && saveOption == SaveOption.ForceUpdate)
            {
                try
                {
                    File.Delete(imagePath);
                }
                catch (IOException exc)
                {
                    // todo возможно, тут добавить файл в очередь на удаление или перезапись новым содержимым
                    // когда он перестанет быть блокированным
                    MapsTraceSource.Instance.ServerInformationTraceSource.TraceInformation("{0} - error while deleting tile {1}: {2}", ServerName, id, exc.Message);
                    errorWhileDeleting = true;
                }
            }

            bool shouldSave = saveOption == SaveOption.ForceUpdate && !errorWhileDeleting ||
                saveOption == SaveOption.PreserveOld && !containsOld;
            if (shouldSave)
            {
                MapsTraceSource.Instance.ServerInformationTraceSource.TraceInformation(String.Format("{0}: begin to save: id = {1}", ServerName, id));
                FileMap[id] = true;

                Statistics.IntValues["ImagesSaved"]++;

                BitmapSource bmp = image;
                if (!bmp.IsFrozen) { 
                }

                ThreadPool.QueueUserWorkItem(new WaitCallback((unused) =>
                {
                    // Try to write tile to cache. Conflicts are possible
                    // especially in case of multiple Map control instances.
                    // That's why exception is only dumped to debug output.
                    try 
                    {
                        if (stream == null)
                        {
                            ScreenshotHelper.SaveBitmapToFile(bmp, imagePath);
                        }
                        else
                        {
                            ScreenshotHelper.SaveStreamToFile(stream, imagePath);
                        }
                    }
                    catch (Exception exc)
                    {
                        Debug.WriteLine(String.Format("Error writing tile to cache: {0}", exc.Message));
                    }
                }));
            }
        }

        protected override string GetNameByIndex(TileIndex index)
        {
            int level = (int)index.Level;
            int x = index.X; //MapTileProvider.GetSideTilesCount(level) + index.X - 1;
            int y = index.Y; //MapTileProvider.GetSideTilesCount(level) - index.Y - 2;

            var result = String.Format("{0}_{1}", x.ToString(), y.ToString());
            return result;
        }