Recursos de imagem WPF

Eu venho de uma experiência principalmente na Web e um pouco no Windows Forms. Para um novo projeto, usaremos o WPF. O aplicativo WPF precisará de 10 a 20 pequenos ícones e imagens para fins ilustrativos. Estou pensando em armazená-los no assembly como recursos incorporados. Esse é o caminho certo a seguir?

Como especificar no XAML que um controle de imagem deve carregar a imagem de um recurso incorporado?

Se você usar a imagem em vários locais, vale a pena carregar os dados da imagem apenas uma vez na memória e compartilhá-los entre todos os Imageelementos.

Para fazer isso, crie a BitmapSource as a resource em algum lugar:

<BitmapImage x:Key="MyImageSource" UriSource="../Media/Image.png" />

Em seguida, no seu código, use algo como:

<Image Source="{StaticResource MyImageSource}" />

No meu caso, descobri que precisava definir o Image.pngarquivo para ter uma ação de compilação, Resourcee não apenas Content. Isso faz com que a imagem seja carregada dentro do seu assembly compilado.

Eu descobri que a melhor prática de usar imagens, vídeos etc. é:

• Altere seus arquivos "Ação de criação" para "Conteúdo" . Certifique-se de verificar Copiar para criar o diretório .
  • Encontrado no menu "Clique com o botão direito" na janela do Solution Explorer.
• Origem da imagem no seguinte formato:
  • "/ « YourAssemblyName » ; component /« YourPath »/ « YourImage.png » "

Exemplo

<Image Source="/WPFApplication;component/Images/Start.png" />

Benefícios:

• Os arquivos não são incorporados ao assembly.
  • O Gerenciador de Recursos levantará alguns problemas de estouro de memória com muitos recursos (em tempo de construção).
• Pode ser chamado entre montagens.

Algumas pessoas estão perguntando sobre fazer isso no código e não obtendo uma resposta.

Depois de passar muitas horas pesquisando, encontrei um método muito simples, não encontrei exemplo e, portanto, compartilho o meu aqui, que funciona com imagens. (o meu era um .gif)

Resumo:

Ele retorna um BitmapFrame que os "destinos" do ImageSource parecem gostar.

Usar:

doGetImageSourceFromResource ("[YourAssemblyNameHere]", "[YourResourceNameHere]");

Método:

static internal ImageSource doGetImageSourceFromResource(string psAssemblyName, string psResourceName)
{
    Uri oUri = new Uri("pack://application:,,,/" +psAssemblyName +";component/" +psResourceName, UriKind.RelativeOrAbsolute);
    return BitmapFrame.Create(oUri);
}

Aprendizados:

Pelas minhas experiências, a sequência do pacote não é o problema, verifique seus fluxos e, especialmente, se a leitura pela primeira vez definir o ponteiro para o final do arquivo e você precisar redefinir para zero antes de ler novamente.

Espero que isso poupe as muitas horas que eu gostaria que esta peça tivesse para mim!

No código para carregar um recurso no assembly em execução em que minha imagem Freq.pngestava na pasta Iconse definida como Resource:

this.Icon = new BitmapImage(new Uri(@"pack://application:,,,/" 
    + Assembly.GetExecutingAssembly().GetName().Name 
    + ";component/" 
    + "Icons/Freq.png", UriKind.Absolute)); 

Eu também fiz uma função:

/// <summary>
/// Load a resource WPF-BitmapImage (png, bmp, ...) from embedded resource defined as 'Resource' not as 'Embedded resource'.
/// </summary>
/// <param name="pathInApplication">Path without starting slash</param>
/// <param name="assembly">Usually 'Assembly.GetExecutingAssembly()'. If not mentionned, I will use the calling assembly</param>
/// <returns></returns>
public static BitmapImage LoadBitmapFromResource(string pathInApplication, Assembly assembly = null)
{
    if (assembly == null)
    {
        assembly = Assembly.GetCallingAssembly();
    }

    if (pathInApplication[0] == '/')
    {
        pathInApplication = pathInApplication.Substring(1);
    }
    return new BitmapImage(new Uri(@"pack://application:,,,/" + assembly.GetName().Name + ";component/" + pathInApplication, UriKind.Absolute)); 
}

Uso (suposição de que você coloque a função em uma classe ResourceHelper):

this.Icon = ResourceHelper.LoadBitmapFromResource("Icons/Freq.png");

Nota : consulte URIs do pacote MSDN no WPF :
pack://application:,,,/ReferencedAssembly;component/Subfolder/ResourceFile.xaml

Sim, é o caminho certo.

Você pode usar a imagem no arquivo de recurso usando o caminho:

<Image Source="..\Media\Image.png" />

Você deve definir a ação de compilação do arquivo de imagem como "Recurso".

Descrição completa de como usar recursos: Arquivos de Recursos, Conteúdo e Dados do Aplicativo WPF

E como referenciá-los, leia "Pack URIs in WPF".

Em resumo, existem meios para referenciar recursos de assemblies referenciados / referenciados.

1. Visual Studio 2010 Professional SP1.
2. Perfil do Cliente .NET Framework 4.
3. Imagem PNG adicionada como recurso nas propriedades do projeto.
4. Novo arquivo na pasta Recursos criado automaticamente.
5. Crie ação definida como recurso.

Isso funcionou para mim:

<BitmapImage x:Key="MyImageSource" UriSource="Resources/Image.png" />

Se você estiver usando o Blend , para torná-lo mais fácil e sem problemas para obter o caminho correto para o atributo Origem , basta arrastar e soltar a imagem do painel Projeto no designer.

Sim, é o caminho certo. Você pode usar imagens no arquivo Recurso usando um caminho:

<StackPanel Orientation="Horizontal">
    <CheckBox  Content="{Binding Nname}" IsChecked="{Binding IsChecked}"/>
    <Image Source="E:\SWorking\SharePointSecurityApps\SharePointSecurityApps\SharePointSecurityApps.WPF\Images\sitepermission.png"/>
    <TextBlock Text="{Binding Path=Title}"></TextBlock>
</StackPanel>

O seguinte funcionou e as imagens a serem configuradas são recursos nas propriedades:

    var bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(MyProject.Properties.Resources.myImage.GetHbitmap(),
                                      IntPtr.Zero,
                                      Int32Rect.Empty,
                                      BitmapSizeOptions.FromEmptyOptions());
    MyButton.Background = new ImageBrush(bitmapSource);
img_username.Source = bitmapSource;