VB .NET- Usando imagens com Embeded Resources

VB .NET- Usando imagens como um recurso embutido (Embedded Resource)

Ao utilizar imagens e arquivos texto em sua aplicação .NET pode ser mais conveniente embutir estas imagens e arquivos como resources(recursos) no seu projeto, ao invés de deixar as imagens e arquivos texto como arquivos separados e depois tentar localizar e carregar as imagens do disco quando a aplicação estiver em execução.

Este artigo mostra como você pode usar imagens e texto como um recurso embutido em seu projeto usando o Visual Basic 2010 Express Edition, mas os conceitos aqui apresentados podem ser aplicados da mesma forma ao Visual Studio 2010 ou ao Visual C# 2010 Express Edition.

Incluindo uma imagem como um Recurso embutido (Embeded Resource)

Abra o Visual Basic 2010 Express Edition (ou o Visual Studio ou o Visual C# 2010, a seu critério) crie um novo projeto do tipo Windows Forms Application chamado ImagemRecursoEmbutido;

Para incluir uma imagem em seu projeto como um recurso embutido siga os seguintes passos:

No menu Project clique na opção Add Existing Item, na janela de seleção, escolha o local de onde você deseja selecionar a imagem, selecione-a e clique no botão Add;

Na janela Solution Explorer do seu projeto você deverá ver a imagem selecionada;
Clique sobre a imagem e pressione F4 para exibir a janela de propriedades;
Na janela de propriedades altere a propriedade Build Action de Content para Embedded Resource, como mostra a figura abaixo:

Compile o projeto usando a opção Build no menu Debug;
Pronto sua imagem será compilada junto com o assembly do seu projeto;

Lendo a imagem embutida

Agora vamos ler a imagem que embutidos como recurso em nosso projeto.

Para fazer isso precisamos primeiro declarar os seguintes namespaces no projeto:

Imports System.IO Imports System.Reflection	using System.IO; using System.Reflection;
VB .NET	C#

Após isso podemos usar o seguinte trecho de código abaixo para ler a imagem:

Dim myAssembly As Assembly = Assembly.GetExecutingAssembly()
Dim myStream As Stream = myAssembly.GetManifestResourceStream("MyNamespace.SubFolder.MyImage.bmp")
Dim bmp As New Bitmap(myStream)

VB .NET

Assembly myAssembly = Assembly.GetExecutingAssembly();
Stream myStream = myAssembly.GetManifestResourceStream( "MyNamespace.SubFolder.MyImage.bmp" );
Bitmap bmp = new Bitmap( myStream );

Vamos entender para depois aplicarmos ao nosso projeto...

Para podermos carregar a imagem armazenada como um recurso embutido temos que obter o caminho correto da imagem. O caminho do recurso possui o seguinte formato:

<namespace>.<subfolders>.<image name>.<extension>

Onde temos:

namespace - é o namespace para o projeto;
subfolders - é a caminho da pasta no interior do projeto, cada pasta é separada por um ponto ou invés de uma barra;
image name - é o nome do arquivo imagem;
extension - é a extensão do arquivo imagem (Ex: "bmp" , "jpg")

Observação : O caminho do arquivo para arquivos usados como recursos embutidos é case sensitive.

Para o nosso exemplo, temos que o namespace é o nome projeto - ImagemRecursoEmbutido - e como carregamos a imagem de nome Desert Landscape.jpg diretamente na raiz do projeto e não criamos uma pasta para guardar a imagem (seria mais indicado) teríamos o seguinte formato no caminho do recurso:

imagemRecursoEmbutido.Desert Landscape.jpg

Se tivéssemos criado uma pasta chamada Imagens no projeto e colocado a imagem nesta pasta o caminho o formato do caminho seria:

imagemRecursoEmbutido.Imagens.Desert Landscape.jpg

Vamos então aplicar a regra acima para mostrar a imagem usada no projeto exemplo deste artigo.

Inclua no formulário do projeto , form1.vb , um controle PictureBox - picImagem e um controle Button - btnExibirImagens conforme o leiaute da figura abaixo:

No evento Click do botão de comando vamos colocar o código que irá ler o arquivo e exibi-lo no controle PictureBox:

Private Sub btnExibirImagens_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnExibirImagens.Click
        Try
            Dim myAssembly As Assembly = Assembly.GetExecutingAssembly()
            Dim myStream As Stream = myAssembly.GetManifestResourceStream("ImagemRecursoEmbutido.Desert Landscape.jpg")
            Dim bmp As New Bitmap(myStream)
            picImagem.Image = bmp
        Catch ex As Exception
            MsgBox("<< Erro ao ler a imagem >> " & ex.Message)
        End Try
    End Sub

A versão do código para a linguagem C# seria:

private void btnExibirImagens_Click(System.Object sender, System.EventArgs e)
{
try {
Assembly myAssembly = Assembly.GetExecutingAssembly();
Stream myStream = myAssembly.GetManifestResourceStream("ImagemRecursoEmbutido.Desert Landscape.jpg");
Bitmap bmp = new Bitmap(myStream);
picImagem.Image = bmp;
} catch (Exception ex) {
Interaction.MsgBox("<< Erro ao ler a imagem >> " + ex.Message);
}
}

Executando o projeto iremos obter:

Além disso você pode exibir todas as imagens embutidas e seus respectivos caminhos. É uma forma de você saber o caminho das imagens no seu projeto.

Aplicando isso ao nosso projeto inclua um controle ListBox-lstbImagens no formulário form1 e um novo controle Button-btnExibirNomeImagens conforme o leiaute abaixo:

No evento Click do botão de comando btnExibirNomesImagens inclua o código abaixo:

Private Sub btnExibirNomesImagens_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnExibirNomesImagens.Click
        Dim myAssembly As Assembly = Assembly.GetExecutingAssembly()
        Dim nomes As String() = myAssembly.GetManifestResourceNames()
        For Each nome As String In nomes
            lstbImagens.Items.Add(nome)
        Next
    End Sub

A versão para linguagem C# do código acima é :

private void btnExibirNomesImagens_Click(System.Object sender, System.EventArgs e)
{
Assembly myAssembly = Assembly.GetExecutingAssembly();
string[] nomes = myAssembly.GetManifestResourceNames();
foreach (string nome in nomes) {
lstbImagens.Items.Add(nome);
}
}

Executando o projeto iremos obter:

Obs: Observe que serão exibidos outros recursos que estão embutidos além das imagens.

Podemos também obter o assembly e o namespace usando Reflection. Veja a seguir o código que pode ser usado para este fim:

' Obter o assembly
Dim executing_assembly As System.Reflection.Assembly = Me.GetType.Assembly.GetEntryAssembly()

'Obter o namespace
Dim my_namespace As String = executing_assembly.GetName().Name.ToString()

Como já dissemos no início, além dos arquivos de imagens podemos embutir também arquivos textos. O procedimento para embutir o arquivo é o mesmo descrito no início do arquivo.

Vamos incluir um arquivo texto chamado cdvbn.txt como um recurso embutido no projeto selecionando o arquivo e alterando sua propriedade Build Action para Embedded Resource.

A seguir inclua no formulário form1.vb um controle TextBox=txtArquivo com Multiline=True e um novo botão de comando com name=btnExibirTexto , conforme o leiaute abaixo:

No evento Click do botão inclua o código que irá obter o assembly, o namespace e ler o arquivo texto exibindo no formulário:

Private Sub btnExibirTexto_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnExibirTexto.Click

       'obtem o assembly
        Dim executing_assembly As System.Reflection.Assembly = Assembly.GetEntryAssembly()

        'Obtem o namespace
        Dim my_namespace As String = executing_assembly.GetName().Name.ToString()

      ' Carrega o arquivo texto
        Dim texto_stream As Stream = executing_assembly.GetManifestResourceStream(my_namespace + ".cdvbn.txt")

        If Not (texto_stream Is Nothing) Then
            'le o arquivo texto e exibe o texto no controle TextBox
            Dim stream_reader As New StreamReader(texto_stream)
            txtArquivo.Text = stream_reader.ReadToEnd()
            stream_reader.Close()
        End If

    End Sub

Para ler o arquivo usamos um StreamReader e o método ReadToEnd().

A versão para a linguagem C# do código acima é dada abaixo:

private void btnExibirTexto_Click(System.Object sender, System.EventArgs e)
{
//obtem o assembly
System.Reflection.Assembly executing_assembly = Assembly.GetEntryAssembly();

//Obtem o namespace
string my_namespace = executing_assembly.GetName().Name.ToString();

// Carrega o arquivo texto
Stream texto_stream = executing_assembly.GetManifestResourceStream(my_namespace + ".cdvbn.txt");

if ((texto_stream != null)) {
     StreamReader stream_reader = new StreamReader(texto_stream);
     txtArquivo.Text = stream_reader.ReadToEnd();
     stream_reader.Close();
   }
}

Executando o projeto iremos obter:

Dessa forma você aprendeu a usar imagens e texto como arquivos embutidos de recurso no seu projeto.

Simples , simples assim

Pegue o projeto completo aqui: ImagemRecursoEmbutido.zip

Eu sei é apenas C# e VB .NET, mas eu gosto...

Referências:

José Carlos Macoratti

Exibindo imagens armazenadas em um Banco de dados - Macoratti.net

WPF - Visualizador de Imagens - Macoratti.net

Windows Mobile - Manipulando Imagens - Macoratti.net

Exibindo imagens e miniaturas - Macoratti.net

GridView - Exibindo images sob determinado critério - Macoratti.net