C#

byte[] pictureByteArray = new byte[0];
            object pictureObject = new object();
            Collection<PSObject> results = powershellExchange.Invoke();
            foreach (PSObject result in results)
            {
                //MessageBox.Show(result.Properties["PictureData"].ToString());
                pictureObject = (result.Properties["PictureData"].Value);
                pictureByteArray = Encoding.ASCII.GetBytes(result.Properties["PictureData"].ToString());
                //pictureByteArray = BinaryReader
                
                
            }

            byte[] originalCoverData;
            BinaryFormatter bf = new BinaryFormatter();
            using (var ms = new MemoryStream())
            {
                bf.Serialize(ms, pictureObject);
                originalCoverData = ms.ToArray();
            }

            //http://stackoverflow.com/questions/3801275/how-to-convert-image-in-byte-array/16576471#16576471


            
            //string imageUrl = "http://www.gazzetta.it/Media/Foto/2007/04/17/1900384--346x212.jpg";

            //originalCoverData = new System.Net.WebClient().DownloadData(imageUrl);
            Image x = null;
            x = byteArrayToImage(originalCoverData);

            System.IO.MemoryStream stream = new System.IO.MemoryStream(originalCoverData);
            
            

            pbxDisplayPicture.Image = x;

            System.Drawing.Image img2 = System.Drawing.Image.FromStream(stream);

            pbxDisplayPicture.Image = img2;

public Image byteArrayToImage(byte[] byteArrayIn)
        {
            using (MemoryStream mStream = new MemoryStream(byteArrayIn))
            {
                return Image.FromStream(mStream);
            }
        }

private bool disposed;
protected virtual void Dispose(bool disposing)
{
    if (!disposed)
    {
        if (_Session != null) // _Session is the COM object.
        {
            _Session.EndSession();       // These are the COM functions to close and end the 
            _Session.CloseConnection();  // session that must be called, but this is where I
            _Session = null;             // get the InvalidComObjectException.
        }
        disposed = true;
    }
}
public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);

}
~SessionConnection() // This was added, which seems to be the root cause of the COM exception
{
    Dispose(false);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.ComponentModel;
namespace test2Enumressource
{
    class Program
    {
      private const uint LOAD_LIBRARY_AS_DATAFILE = 0x00000002;

      [DllImport("kernel32.dll", SetLastError = true)]
      private static extern IntPtr LoadLibraryEx(
        string lpFileName,
        IntPtr hFile,
        uint dwFlags);

      [DllImport("kernel32.dll", SetLastError = true)]
      private static extern bool FreeLibrary(IntPtr hModule);

#region équivalent des macros
      private static bool IS_INTRESOURCE(IntPtr value)
      {
          if (((uint)value) > ushort.MaxValue)
              return false;
          return true;
      }
      private static uint GET_RESOURCE_ID(IntPtr value)
      {
          if (IS_INTRESOURCE(value) == true)
              return (uint)value;
          throw new System.NotSupportedException("value is not an ID!");
      }
      private static string GET_RESOURCE_NAME(IntPtr value)
      {
          if (IS_INTRESOURCE(value) == true)
              return value.ToString();
          return Marshal.PtrToStringUni((IntPtr)value);
      }
#endregion équivalent des macros

#region Enumération des langues des ressources
      [DllImport("kernel32.dll")]
      static extern bool EnumResourceLanguages(IntPtr hModule, IntPtr lpszType,
          IntPtr lpName, EnumResLangDelegate lpEnumFunc, IntPtr lParam);

      private delegate bool EnumResLangDelegate(
          IntPtr hModule,
          IntPtr lpszType,
          IntPtr lpszName,
          ushort wIDLanguage,
          IntPtr lParam);

      private static bool EnumResLangCallback(
          IntPtr hModule,
          IntPtr lpszType,
          IntPtr lpszName,
          ushort wIDLanguage,
          IntPtr lParam)
      {
          Console.WriteLine("\t\tLanguage: {0}", wIDLanguage);
          return true;
      }
#endregion Enumération des langues des ressources

#region Enumération des noms des ressources
      [DllImport("kernel32.dll",
        CharSet = CharSet.Unicode, SetLastError = true)]
      static extern bool EnumResourceNames(
        IntPtr hModule,
        IntPtr lpszType,
        EnumResNameDelegate lpEnumFunc,
        IntPtr lParam);

      private delegate bool EnumResNameDelegate(
        IntPtr hModule,
        IntPtr lpszType,
        IntPtr lpszName,
        IntPtr lParam);

      static bool EnumRes(
          IntPtr hModule,
          IntPtr lpszType,
          IntPtr lpszName,
          IntPtr lParam)
      {
         Console.WriteLine("\tName: {0}", GET_RESOURCE_NAME(lpszName));
         bool bret =  EnumResourceLanguages(hModule, lpszType,
            lpszName, new EnumResLangDelegate(EnumResLangCallback), lParam);

         if (bret == false)
         {
             throw new Win32Exception(Marshal.GetLastWin32Error());
         }

          return true;
      }
#endregion Enumération des noms des ressources

#region Enumération des types des ressources
      private delegate bool d_EnumResourceTypes(
        IntPtr hModule,
        IntPtr lpszType,
        long lParam);

      [DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
      private extern static long EnumResourceTypes(IntPtr hModule, d_EnumResourceTypes callback, long lParam);

      static bool EnumResourceTypesCallback(IntPtr hModule, IntPtr lpszType, long lParam)
      {
          if (IS_INTRESOURCE(lpszType))
          {
              Console.WriteLine("Type : {0}", GET_RESOURCE_ID(lpszType));
          }
          else
          {
              Console.WriteLine("Type : {0}", GET_RESOURCE_NAME(lpszType));
          }

        if (EnumResourceNames(hModule,lpszType,
        new EnumResNameDelegate(EnumRes), IntPtr.Zero) == false)
        {
            Console.WriteLine("erreur: {0}", Marshal.GetLastWin32Error());
        }
        return true;
      }
#endregion Enumération des types des ressources

      [STAThread]
      static void Main(string[] args)
      {
          string  file = @"C:\windows\system32\notepad.exe";
          if (args.Length == 1){
              file = args[0];
          }
          IntPtr hMod = LoadLibraryEx(file, IntPtr.Zero, LOAD_LIBRARY_AS_DATAFILE);

        long lParam = 0;
        EnumResourceTypes(hMod, new d_EnumResourceTypes(EnumResourceTypesCallback), lParam);

        FreeLibrary(hMod);
      }
    }
}

public class Toy
{
   public int ID{get;set;}
   public double Price{get;set;}
   public sting Color{get; set;}
}
public class Merchandise
{
  public List<Toy> toyList;
  public Merchandise()
  {
    toyList= new List<Toys>();
    toyList.Add(new Toy {ID = 1, Price = 10, Color = "Red"});
    toyList.Add(new Toy {ID = 2, Price = 10, Color = "White"});
    toyList.Add(new Toy {ID = 3, Price = 10, Color = "Black"});
  }
  
  public string this[int toyId, string toyProperty]
  {
   get{return listOfProducts.FirstOrDefault(prod => prod.Id == productId);}
   set{listOfProducts.FirstOrDefault(prod => prod.Id == productId).toyProperty = value;}
  }      
}

public double price = txtPrice.Text;
public string color = txtColor.Text;

public Merchandise item = new Merchandise();
//Change Price Dynamically
item[2, "Price"].Price = price;

//Change Color Dynamically
item[2, "Color"].Color = color;