silverlight游戏设计（二）资源管理篇(下)--资源的状态通知、管理与缓存

在上篇中，我们实现了一个带有池化、并发连接限制能力的资源下载器，虽然这个下载器能够使我们的游戏动态加载资源并在加载完毕/失败后调用回调方法。但是还是缺乏一些智能。比如我要加载一个game_role_petegg.zip的资源包，如我们有需求：

1.对已经下载过的资源不再重复下载。

2.下载过的资源要缓存，一方面存在内存中，一方面存在isolatedstorage中。

实现这些功能会极大的提高用户体验，所我们有必要设计一个带有缓存控制能力的资源管理器。

复用已有的DownloadDelegater

搞开发的嘛，不可能每一个需求都单独写一片代码，这要将对象的职责分离清楚，复用还是很容易的。

我们定义需求接口：

public   interface  IWebClientResourceService 
    { 
         void  Load(Uri uri, DownloadResultEventHandler callback); 
         void  PutIsolatedStorageToMemoryCache(Uri uri); 
         void  PutMemoryCacheToIsolatedStorage(Uri uri); 
         void  RemoveCache(Uri uri); 
    }

 

 

Load方法会下载指定uri的资源，如果之前已经在下载过就不会重复下载。

PutIsolatedStorageToMemoryCache将隔离存储中的数据加载到内存中。

PutMemoryCacheToIsolatedStorage将内存数据保存到隔离存储。

下面通过组合的方式复用之前的DownloadDelegater。

WebClientResourceService

namespace  Sopaco.Silverlight.Insfrastructure.Net.DownloadActivator
{
     public   class  WebClientResourceService : Sopaco.Silverlight.Insfrastructure.Net.DownloadActivator.IWebClientResourceService
    {
         public   static   readonly  WebClientResourceService Instance;
         static  WebClientResourceService()
        {
            Instance  =   new  WebClientResourceService();
        }
         private  Dictionary < Uri, DownloadTask >  _resourceCacher  =   new  Dictionary < Uri, DownloadTask > ();
         private  DownloadDelegater _downloadDelegater  =   new  DownloadDelegater();

         private   object  _locker_ResourceCacher  =   new   object ();

         public   void  Load(Uri uri, DownloadResultEventHandler callback)
        {
             #region  检查是否已经有缓存
             lock  (_locker_ResourceCacher)
            {
                 if  (_resourceCacher.ContainsKey(uri))
                {
                     if  (callback  !=   null )
                    {
                        var task  =  _resourceCacher[uri];
                        callback(task.CloneStream, task.Status);
                    }
                     return ;
                }
                _resourceCacher[uri]  =   new  DownloadTask()
                {
                    Uri  =  uri,
                    Stream  =   null ,
                    Status  =  DownloadStatus.UnStarted
                };
            }
             #endregion
             #region  使用下载器下载
            _downloadDelegater.Download(uri, (stream, status)  =>  
                    {
                        onResultArrive(uri, status, stream);
                         if (callback  !=   null )
                            callback(stream, status);
                    });
             if  (_resourceCacher[uri].Status  ==  DownloadStatus.UnStarted) // 防止过快下载而使状态不同步
            {
                _resourceCacher[uri].Status  =  DownloadStatus.Running;
            }
             #endregion
        }
         ///   <summary>
         ///  移除缓存
         ///  未防止缓存内容过大导致内存持续消耗，应该适当调用此方法移出缓存(或者存放在隔离存储中？)
         ///   </summary>
         public   void  RemoveCache(Uri uri)
        {
             lock  (_locker_ResourceCacher)
            {
                 if  (_resourceCacher.ContainsKey(uri))
                {
                    var cacheObj  =  _resourceCacher[uri];
                     if (_resourceCacher.Remove(uri))
                    {
                        cacheObj.Dispose();
                    }
                     else
                    {
                        System.Diagnostics.Debug.WriteLine( " 移除资源异常：无法移除资源@ "   +  System.Reflection.MethodInfo.GetCurrentMethod().ToString());
                    }
                }
            }
        }
         ///   <summary>
         ///  将一个资源缓存到隔离存储中
         ///   </summary>
         ///   <param name="uri"></param>
         public   void  PutMemoryCacheToIsolatedStorage(Uri uri)
        {
             if (_resourceCacher.ContainsKey(uri))
            {
                IsolateStorageRespository.Instance.AddWithOverwrite(uri.ToString(), _resourceCacher[uri]);
            }
        }
         ///   <summary>
         ///  从隔离存储中将一个资源缓存起来
         ///   </summary>
         ///   <param name="uri"></param>
         public   void  PutIsolatedStorageToMemoryCache(Uri uri)
        {
             if  (_resourceCacher.ContainsKey(uri))
            {
                var cache  =  IsolateStorageRespository.Instance.Get < DownloadTask > (uri.ToString());
                 if (cache  !=   null )
                {
                    _resourceCacher[uri]  =  cache;
                }
            }
        }
         private   void  onResultArrive(Uri uri, DownloadStatus status, MemoryStream stream)
        {
            _resourceCacher[uri].Status  =  status;
            _resourceCacher[uri].Stream  =  stream;
        }
    }
}

 

 

进一步使用

上面的WebClientResourceService功能还是有些“大一统”，我们可以进一步针对一些特定资源进行应用。

示例需求：对于图片资源包和一些零散的没有放到资源包里的图片资源，一旦下载下来将其放到隔离存储中，下次再需要下载此图片时就直接从隔离存储中取得（如果资源有更新的话将隔离存储中的数据清除就ok）。

GameImageResService

namespace  Sopaco.Silverlight.GameFramewrok.GameRes
{
     ///   <summary>
     ///  应用WebClientResourceService定制的一个游戏资源服务模块
     ///   </summary>
     public   class  GameImageResService
    {
         #region  make it a singleton
         public   static   readonly  GameImageResService Instance;
         static  GameImageResService()
        {
            Instance  =   new  GameImageResService();
        }
         public  GameImageResService()
        {

        }
         #endregion
         private   static   readonly   string  IMG_ZIP_XML  =   " resconfig.xml " ;
         private  WebClientResourceService _resourceService  =  WebClientResourceService.Instance;
         private  Dictionary < Uri, BitmapImage >  _imageCache  =   new  Dictionary < Uri, BitmapImage > ();
         private  Dictionary < string , BitmapImage >  _namedImageCache  =   new  Dictionary < string , BitmapImage > ();
         ///   <summary>
         ///  图片资源
         ///   </summary>
         public   void  GetBitmapImage(Uri uri, Action < BitmapImage >  callback)
        {
             if (_imageCache.ContainsKey(uri))
            {
                callback(_imageCache[uri]);
                 return ;
            }
            _resourceService.Load(uri, (stream, status)  =>  
                {
                     if (status  ==  DownloadStatus.Completed)
                    {
                        var image  =   new  BitmapImage();
                        image.SetSource(stream);
                        _imageCache[uri]  =  image;
                        _resourceService.PutMemoryCacheToIsolatedStorage(uri); // 图片资源由GameResService托管，将WebClientResourceService中的缓存持久化
                        callback.ExecuteSecurity(image);
                    }
                     else
                    {
#if  DEBUG
                         throw   new  Exception( " error in resource downloading " );
#endif
                    }
                });
        }
         ///   <summary>
         ///  载入一个zip资源包中的图片资源
         ///   </summary>
         /* 配置文件格式
         * resconfig.xml
         * <?……?>
         * <AppRoot>
         * <ImgResSection><Image key="……" uri="……" /></ImgResSection>
         * </AppRoot>
         * #endregion
          */
         public   void  GetBitmapImageInZip(Uri uri, Action onZipLoaded, Action onResourcesLoad)
        {
            _resourceService.Load(uri, (stream, status)  =>
            {
                 if (status  !=  DownloadStatus.Completed)
                {
#if  DEBUG
                     throw   new  Exception( " error in download resource " );
#endif
                }
                onZipLoaded.ExecuteSecurity();
                StreamResourceInfo info  =   new  StreamResourceInfo(stream,  null );
                 using  (var reader  =   new  StreamReader(Application.GetResourceStream(info,  new  Uri(IMG_ZIP_XML, UriKind.Relative)).Stream))
                {
                    var xmlReader  =  XmlReader.Create(reader);
                     while (xmlReader.Read())
                    {
                         if (xmlReader.IsStartElement( " ImgResSection " ))
                        {
                             while (xmlReader.Read())
                            {
                                 if (xmlReader.IsStartElement( " Image " ))
                                {
                                    xmlReader.MoveToAttribute( " key " );
                                    xmlReader.ReadAttributeValue();
                                     string  imgKey  =  xmlReader.Value;
                                    xmlReader.MoveToAttribute( " uri " );
                                    xmlReader.ReadAttributeValue();
                                    var targetUri  =   new  Uri(xmlReader.Value, UriKind.RelativeOrAbsolute);
                                    var bitmapStream  =  Application.GetResourceStream(info, targetUri).Stream;
                                    var image  =   new  BitmapImage();
                                    image.SetSource(bitmapStream);
                                    _namedImageCache[imgKey]  =  image;
                                }
                            }
                        }
                    }
                }
                onResourcesLoad.ExecuteSecurity();
                 #region  zip图片资源包由GameResService托管，将WebClientResourceService中的缓存持久化
                _resourceService.PutMemoryCacheToIsolatedStorage(uri);
                 #endregion
            });
        }
         public  BitmapImage GetImageByUri(Uri uri)
        {
             if  ( ! _imageCache.ContainsKey(uri))
                 return   null ;
             return  _imageCache[uri];
        }
         public  BitmapImage GetImageBySpecialName( string  key)
        {
             if ( ! _namedImageCache.ContainsKey(key))
                 return   null ;
             return  _namedImageCache[key]; 
        }
    }
}

 

 

本文源码下载

 最后祝大家圣诞快乐Merry Christmas!