13

次のコードを使用して、Web サーバーから画像を表示します。

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

画像は自動的にダウンロードされ、URL に基づくキャッシュもあると思います。

私の問題は、アプリがオフラインの場合、キャッシュされたと思われる画像が表示されないことです。

ネットワークが使用できない場合にも画像が読み込まれるように、キャッシュの動作を変更する方法はありますか? キャッシュに関するドキュメントへのポインタも非常に役立ちます。

4

5 に答える 5

5

私はあなたのための解決策を持っています。それはJetImageLoaderです。大量のロゴやアイコンなどをロード、キャッシュ、表示する必要があるアプリケーション用に作成しました。

バインディング コンバーターとして使用できるため、コードを変更する必要さえありません。XAML を更新するだけです。

リポジトリのサンプルをチェックしてください。きっと気に入るはずです ;)

特徴：

  • ディスクへのキャッシュ
  • メモリへのキャッシュ
  • 完全非同期
  • バインディング コンバーターとして、またはコードからプログラムで利用可能
  • 完全にオープンソース、フォークして改善してください！

次に例を示します。

<Image Source="{Binding ImageUrl, Converter={StaticResource MyAppJetImageLoaderConverter}}"/>
于 2013-10-12T22:36:49.480 に答える
1

FFImageLoading を使用することもできます ( https://github.com/molinch/FFImageLoading/ )

特徴

  • Xamarin.iOS (最小 iOS 7)、Xamarin.Android (最小 Android 4)、Xamarin.Forms、および Windows (WinRT、UWP) のサポート
  • 構成可能なディスクとメモリのキャッシュ
  • 同様のダウンロード/ロード要求の重複排除
  • エラーとプレースホルダーの読み込みのサポート
  • 画像は指定したサイズに自動的にダウンサンプリングできます (メモリ使用量が少なくなります)
  • WebP サポート
  • 画像の読み込み フェードイン アニメーションのサポート
  • 画像のダウンロードを再試行できます (RetryCount、RetryDelay)
  • Android では、透過性はデフォルトで無効になっています (構成可能)。メモリの 50% を節約
  • 変換のサポート
    • ぼやけた変換
    • CircleTransformation、RoundedTransformation、CornersTransformation
    • ColorSpaceTransformation、GrayscaleTransformation、SepiaTransformation
    • FlipTransformation
    • カスタム変換をサポート (ネイティブ プラットフォームの ITransformation 実装)

次のように簡単です。

<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/

于 2015-11-24T17:13:06.823 に答える
1

私の解決策：（画像をWebからローカルストレージに保存し、保存した画像をページにバインドします）

XAML

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

データ・モデル

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;
    }
}
于 2016-06-15T06:36:29.080 に答える
1

それを行うためのビルドはないと思いますが、画像を IsolatedStorage に保存し、インターネットの可用性をチェックしてオンラインまたはオフラインの URL を返す Converter を使用できます。

クイック検索でこれが得られました。これはまさにあなたが探しているものかもしれません (Windows Phone 7 と互換性があり、Windows Phone 8 には最適なソリューションではない可能性があります)。

于 2013-06-23T14:15:37.493 に答える