图像源和缓存

Question

我使用以下代码显示来自网络服务器的图像：

   <Image Source="{Binding Url}" />

图像会自动下载，我假设还有一些基于Url的缓存。

我的问题是，当应用程序处于脱机状态时，可能无法显示缓存的图像。

有没有办法改变缓存行为，以便在没有网络可用时加载图像？有关缓存的文档指针也非常有用。

Answer 1

BitmapImage默认自动缓存远程图像。它最好与CreateOptions="BackgroundCreation"一起使用以获得最佳性能。

<Image Height="100" Width="100" Margin="12,0,9,0">
  <Image.Source>
    <BitmapImage UriSource="{Binding ImgURL}" CreateOptions="BackgroundCreation"/>
  </Image.Source>
</Image>

This MSDN blog post，旧的，但仍然相关，列出并解释所有CreationOptions，并且缓存在大多数模式中是自动的。

我使用这些选项显示许多带图像的新闻项目，效果很好。我可以加载文章列表，退出应用程序并将“飞行模式”设置为“打开”，然后启动应用程序的新实例，图像仍然会加载。

手动方法

如果您想自己控制缓存并缓存HTTPS资源，那么几个很好的例子......

ImgCache from the iFixit app
Value converter that downloads and saves images
PersistentImageCache from the Kawagoe Toolkit（可能需要更新才能使用WP 7.5或8）

Answer 2

我有一个解决方案给你。它是JetImageLoader，我创建它用于应用程序，我们需要加载，缓存和显示大量的徽标，图标等。

它可以用作绑定转换器，因此您甚至不应该更改代码！只需更新您的XAML！

拜托samples in repository，你会爱上它;）

特征：

在磁盘上缓存
在内存中缓存
完全异步
可用作绑定转换器或以编程方式从代码中获取
完全开源，分叉并改进它！

这是一个例子：

<Image Source="{Binding ImageUrl, Converter={StaticResource MyAppJetImageLoaderConverter}}"/>

Answer 3

我不认为有这样做的方法，但您可以将图像保存在IsolatedStorage中并使用转换器检查互联网可用性并返回在线或离线URL。

A quick search yielded this可能正是您正在寻找的（它与Windows Phone 7兼容，可能不是Windows Phone 8的最佳解决方案）

Answer 4

我的解决方案:(将图像从Web保存到本地存储并将保存的图像绑定到页面）

XAML

<ListView ItemsSource="{Binding Items}">
<ListView.ItemTemplate>
    <DataTemplate>
        <!--Some code removed-->
        <Image Source="{Binding Img_Thumb.Result}" />
    </DataTemplate>
</ListView.ItemTemplate>

的DataModel

public class DataModel_ListOfEvents
{
    public DataModel_ListOfEvents(String img_thumb)
    {
        this.Img_Thumb = new NotifyTaskCompletion<string>(JsonCached.ImageFromCache2(img_thumb));
    }
    public NotifyTaskCompletion<string> Img_Thumb { get; private set; }
}

public sealed class SampleData_ListOfEvents
{
    private static SampleData_ListOfEvents _sampleDataSource = new SampleData_ListOfEvents();

    private ObservableCollection<DataModel_ListOfEvents> _items = new ObservableCollection<DataModel_ListOfEvents>();
    public ObservableCollection<DataModel_ListOfEvents> Items { get { return this._items; } }
}

魔法

public class JsonCached
{
    public static async Task<string> ImageFromCache2(string path)
    {
        int ru = path.IndexOf(".ru") + 4;// TODO: .com .net .org
        string new_path = path.Substring(ru).Replace("/", "\\");

        StorageFolder localFolder = ApplicationData.Current.LocalFolder;
        try
        {
            Stream p = await localFolder.OpenStreamForReadAsync(new_path);
            p.Dispose();
            System.Diagnostics.Debug.WriteLine("From cache");
            return localFolder.Path + "\\" + new_path;
        }
        catch (FileNotFoundException)
        {

        }
        catch (Exception e)
        {
            System.Diagnostics.Debug.WriteLine("{0}", e.Message);
        }

        StorageFile storageFile = await localFolder.CreateFileAsync(new_path, CreationCollisionOption.OpenIfExists);

        Uri Website = new Uri(path);
        HttpClient http = new HttpClient();
        // TODO: Check connection. Return message on fail.
        System.Diagnostics.Debug.WriteLine("Downloading started");
        byte[] image_from_web_as_bytes = await http.GetByteArrayAsync(Website);

        MakeFolders(localFolder, path.Substring(ru));

        Stream outputStream = await storageFile.OpenStreamForWriteAsync();
        outputStream.Write(image_from_web_as_bytes, 0, image_from_web_as_bytes.Length);
        outputStream.Position = 0;

        System.Diagnostics.Debug.WriteLine("Write file done {0}", outputStream.Length);

        outputStream.Dispose();
        return localFolder.Path + "\\" + new_path;
    }

    private static async void MakeFolders(StorageFolder localFolder, string path)
    {
        //pics/thumbnail/050/197/50197442.jpg
        int slash = path.IndexOf("/");
        if (slash <= 0) // -1 Not found
            return;

        string new_path = path.Substring(0, slash);
        StorageFolder opened_folder = await localFolder.CreateFolderAsync(new_path, CreationCollisionOption.OpenIfExists);
        string very_new_path = path.Remove(0, new_path.Length + 1);
        MakeFolders(opened_folder, very_new_path);
    }
}

NotifyTaskCompletion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;

namespace App2.NotifyTask
{
    public sealed class NotifyTaskCompletion<TResult> : INotifyPropertyChanged
    {
        public NotifyTaskCompletion(Task<TResult> task)
        {
            Task = task;
            if (!task.IsCompleted)
            {
                var _ = WatchTaskAsync(task);
            }
        }
        private async Task WatchTaskAsync(Task task)
        {
            try
            {
                await task;
            }
            catch
            {
            }
            var propertyChanged = PropertyChanged;
            if (propertyChanged == null)
                return;
            propertyChanged(this, new PropertyChangedEventArgs("Status"));
            propertyChanged(this, new PropertyChangedEventArgs("IsCompleted"));
            propertyChanged(this, new PropertyChangedEventArgs("IsNotCompleted"));
            if (task.IsCanceled)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsCanceled"));
            }
            else if (task.IsFaulted)
            {
                propertyChanged(this, new PropertyChangedEventArgs("IsFaulted"));
                propertyChanged(this, new PropertyChangedEventArgs("Exception"));
                propertyChanged(this,
                  new PropertyChangedEventArgs("InnerException"));
                propertyChanged(this, new PropertyChangedEventArgs("ErrorMessage"));
            }
            else
            {
                propertyChanged(this,
                  new PropertyChangedEventArgs("IsSuccessfullyCompleted"));
                propertyChanged(this, new PropertyChangedEventArgs("Result"));
            }
        }
        public Task<TResult> Task { get; private set; }
        public TResult Result { get { return (Task.Status == TaskStatus.RanToCompletion) ? Task.Result : default(TResult); } }
        public TaskStatus Status { get { return Task.Status; } }
        public bool IsCompleted { get { return Task.IsCompleted; } }
        public bool IsNotCompleted { get { return !Task.IsCompleted; } }
        public bool IsSuccessfullyCompleted { get { return Task.Status == TaskStatus.RanToCompletion; } }
        public bool IsCanceled { get { return Task.IsCanceled; } }
        public bool IsFaulted { get { return Task.IsFaulted; } }
        public AggregateException Exception { get { return Task.Exception; } }
        public Exception InnerException { get { return (Exception == null) ? null : Exception.InnerException; } }
        public string ErrorMessage { get { return (InnerException == null) ? null : InnerException.Message; } }
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

Answer 5

你也可以使用FFImageLoading（https://github.com/molinch/FFImageLoading/）

特征

Xamarin.iOS（最小iOS 7），Xamarin.Android（最小Android 4），Xamarin.Forms和Windows（WinRT，UWP）支持
可配置的磁盘和内存缓存
类似下载/加载请求的重复数据删除
错误和加载占位符支持
图像可以自动下采样到指定的大小（更少的内存使用）
WebP支持
图像加载淡入式动画支持
可以重试图像下载（RetryCount，RetryDelay）
在Android上，默认情况下禁用透明度（可配置）。节省50％的内存
转换支持 BlurredTransformation CircleTransformation，RoundedTransformation，CornersTransformation ColorSpaceTransformation，GrayscaleTransformation，SepiaTransformation FlipTransformation 支持自定义转换（本机平台IT转换实现）

这很简单：

<ff:MvxCachedImage Name="image"
    VerticalAlignment="Stretch" 
    HorizontalAlignment="Stretch"
    LoadingPlaceholder="loading.png"
    ErrorPlaceholder="error.png"
    RetryCount="3"
    RetryDelay="250"
    DownsampleHeight="300"
    ImagePath="http://lorempixel.com/output/city-q-c-600-600-5.jpg">
</ff: MvxCachedImage >

示例项目在这里：https://github.com/molinch/FFImageLoading/tree/master/samples/

图像源和缓存

问题描述投票：12回答：5

5个回答

特征

最新问题

图像源和缓存

问题描述 投票：12回答：5

5个回答

特征

最新问题

问题描述投票：12回答：5