Wie arbeite ich mit Bildern in einem portable Klassenbibliothek für Windows Store-Apps und WP7,WP8,WPF?

Für eine Menge von Fällen, die Bilder sind Plattform-spezifisch. Sie müssen sorgen für die Größe und die DPI des Geräts, auf sich selbst, und brauchen würde, um fit in mit dem look and feel der Anwendung. Für diese Situationen, ich würde die Sicht selbst entscheiden, welche Bilder zu zeigen, die Benutzer, basieren wahrscheinlich auf irgendeine Art von Status - /Modus durch das ViewModel.

Diese sind jedoch Fälle, in denen die Bilder müssen aus dem ViewModel, zum Beispiel im Fall der Absender thumbnails, die angezeigt E-mail-Anwendungen. In diesen Fällen habe ich das ViewModel Rückkehr eine Art Plattform-Agnostiker " - Konzept ein Bild (wie byte[]), und dann haben die Plattform-spezifische Projekte konvertieren, die in etwas, dass Ihre UI-stack versteht (in XAML, wäre dies eine ImageSource).

Würde der code wie folgt Aussehen:

Portable Projekt:

using System.IO;
using System.Reflection;

namespace Portable
{
    public class ViewModel
    {
        private byte[] _image = LoadFromResource("Image.png");

        public byte[] Image
        {
            get { return _image; }
        }

        private static byte[] LoadFromResource(string name)
        {
            using (Stream stream = typeof(ViewModel).GetTypeInfo().Assembly.GetManifestResourceStream("Portable." + name))
            {
                MemoryStream buffer = new MemoryStream();
                stream.CopyTo(buffer);

                return buffer.ToArray();
            }
        }
    }
}

Hinweis:, müssen Sie entfernen oder hinzufügen GetTypeInfo () - abhängig von den Plattformen, die Sie sind targeting.

Hier, wir Lesen von einer eingebetteten Ressource (Eigenschaften -> Build Action -> "Eingebettete Ressource"), aber Sie könnte sich vorstellen, diese kommen aus dem Netzwerk, oder irgendwo anders.

Windows Store-app-Projekt:
In der Windows Store-app, Sie hätte einen Wert Konverter zum umwandeln von byte[] -> ImageSource:

using System;
using System.IO;
using Windows.Storage.Streams;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Media.Imaging;

namespace App
{
    public class ByteToImageSourceValueConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, string language)
        {
            InMemoryRandomAccessStream s = new InMemoryRandomAccessStream();

            byte[] bytes = (byte[])value;
            Stream stream = s.AsStreamForWrite();
            stream.Write(bytes, 0, bytes.Length);
            stream.Flush();
            stream.Seek(0, SeekOrigin.Begin);


            BitmapImage source = new BitmapImage();
            source.SetSource(s);

            return source;           

        }

        public object ConvertBack(object value, Type targetType, object parameter, string language)
        {
            throw new NotImplementedException();
        }
    }
}

In der code-behind der View DataContext:

DataContext = new ViewModel();

Dann in der Ansicht selbst die Bindung an das ViewModel.Image-Eigenschaft, und legen Sie die Konverter:

<Page.Resources>
    <local:ByteToImageSourceValueConverter x:Name="ImageConverter"/>
</Page.Resources>

<Grid >
    <Image HorizontalAlignment="Left" Height="242" Margin="77,10,0,0" VerticalAlignment="Top" Width="278" Source="{Binding Image, Converter={StaticResource ImageConverter}}"/>

</Grid>

Ich Stimme Ihnen zu, dass Bild-handling", sollte wahrscheinlich an eine bestimmte Plattform gebunden. Nur als eine Allgemeine Regel etwas anzeigen Verwandte sollten nicht aufgenommen werden in eine PCL. Die obigen Antworten haben einige große technische detail, dass ich nicht die Mühe zu wiederholen, sondern wollte einen link posten, zu einem dia-deck, das ich zusammengestellt habe, zu diskutieren Prinzipien der Verwendung von PCL. http://prezi.com/ipyzhxvxjvp-/sharing-is-caring-code-reuse-in-xaml-applications/

Ich hoffe, dies gibt einige Allgemeine Hinweise, die gesamte design-Strategien und verstärkt die in den vorhergehenden Antworten.

Mein Erster Instinkt ist, zu sagen, Nein man sollte keine Bilder im PCL-angesichts dessen, was Sie beschrieben haben.

Aber wenn ich im Begriff waren, es zu tun, können Bilder gespeichert werden, die über Ressourcen in den verschiedenen Bibliotheken und speichern Sie ein anderes Bild für jede Plattform gibt, und machen dann eine Umwelt Prüfung, um zu bestimmen, welches Bild zu ziehen. Aber dieser Ansatz wirklich nur versucht werden sollte, wenn Sie eine Skalierung notwendig.

Durch Maßstab-ich meine, Sie sind mit offenen Quellcodes dieser Bibliothek, wo 1000 von Programmen sind, es zu benutzen. Wenn dies für Ihre eigene Verwendung für 3 oder 4 apps, ich würde sagen, nicht die Mühe, speichern Sie Ihre selbst, die Kopfschmerzen. Nur das Bild in der gemeinsam genutzten Bibliothek oder über eine config und mit ihm getan werden.

Oder einfach nicht die Verwaltung von Bildern über die PCL. Da image manipulation änderungen und unterscheidet sich auf jeder Plattform, vor allem für diejenigen, die Sie erwähnt. Und Sie verpflichtet sind, führen Sie in einige seltsame Fehler, bei dem es funktioniert einfach nicht die gleiche wie auf den anderen Plattformen.

können Sie das Bild auf dem view-Modell als Typ "Objekt" und eine Schnittstelle (injiziert) zum erstellen der bitmap.

public interface IBitMapCreator
{
    object Create(string path);
}

public class MyViewModel
{
    private bool _triedToSetThumb;
    private readonly IBitMapCreator _bc;

    public MyViewModel(IBitMapCreator bc, string path)
    {
        _bc = bc;
        SetThumb(path);
    }

    public object Thumb { get; private set; }

    private void SetThumb(string path)
    {
        try
        {
            if (!_triedToSetThumb)
            {
                string ext = Path.GetExtension(path).ToUpper();

                if (
                    ext == ".JPG" ||
                    ext == ".JPEG" ||
                    ext == ".PNG" ||
                    ext == ".GIF" ||
                    ext == ".BMP" ||
                    false
                    )
                {
                    Thumb = _bc.Create(path);
                    OnPropertyChanged(new PropertyChangedEventArgs("Thumb"));
                }
            }
        }
        finally
        {
            _triedToSetThumb = true;
        }
    }

}

in der WPF-version, Sie könnten dies tun

class BitMapCreator : IBitMapCreator
{
    public object Create(string path)
    {
        return BitmapFrame.Create(new Uri(path));
    }
} 

Mithilfe dieser Methode können Sie Daten binden Recht am Bild und nicht ein Konverter nötig.