silverlight导出图片文件

新建一个Silverlight应用程序，添加下面两个控件：

image控件：image1；

Button控件：Click="Button1_Click";

code-Behind代码如下：

         private void Button1_Click(object sender, RoutedEventArgs e)
         {
             ElementToPNG eTP = new ElementToPNG();
             eTP.ShowSaveDialog(image1);
         }

并添加下面三个类：

 //* -------------------------------------------------------------------------------------------------
 //* 下面的三个类是处理图片导出的
 //* -------------------------------------------------------------------------------------------------
 # region Class ElementToPNG
     public class ElementToPNG
     {
         public void ShowSaveDialog(UIElement elementToExport)
         {
             SaveFileDialog sfd = new SaveFileDialog()
             {
                 DefaultExt = "png",
                 Filter = "Png files (*.png)|*.png|All files (*.*)|*.*",
                 FilterIndex =
             };

             if (sfd.ShowDialog() == true)
             {
                 SaveAsPNG(sfd, elementToExport);
             }
         }
         private void SaveAsPNG(SaveFileDialog sfd, UIElement elementToExport)
         {
             WriteableBitmap bitmap = new WriteableBitmap(elementToExport, new TranslateTransform());
             EditableImage imageData = new EditableImage(bitmap.PixelWidth, bitmap.PixelHeight);
             try
             {
                 for (int y = ; y < bitmap.PixelHeight; ++y)
                 {
                     for (int x = ; x < bitmap.PixelWidth; ++x)
                     {
                         int pixel = bitmap.Pixels[bitmap.PixelWidth * y + x];
                         imageData.SetPixel(x, y,
                         (byte)((pixel >> ) & 0xFF),
                         (byte)((pixel >> ) & 0xFF),
                         (byte)(pixel & 0xFF), (byte)((pixel >> ) & 0xFF)
                         );
                     }
                 }
             }
             catch (System.Security.SecurityException)
             {
                 throw new Exception("Cannot print images from other domains");
             }
             Stream pngStream = imageData.GetStream();
             byte[] binaryData = new Byte[pngStream.Length];
             long bytesRead = pngStream.Read(binaryData, , (int)pngStream.Length);
             Stream stream = sfd.OpenFile();
             stream.Write(binaryData, , binaryData.Length);
             stream.Close();
         }
     }
 # endregion

 # region Class EditableImage
     public class EditableImage
     {
         private int _width = ;
         private int _height = ;
         private bool _init = false;
         private byte[] _buffer;
         private int _rowLength;

         public event EventHandler<EditableImageErrorEventArgs> ImageError;

         public EditableImage(int width, int height)
         {
             this.Width = width;
             this.Height = height;
         }

         public int Width
         {
             get
             {
                 return _width;
             }
             set
             {
                 if (_init)
                 {
                     OnImageError("Error: Cannot change Width after the EditableImage has been initialized");
                 }
                 else if ((value <= ) || (value > ))
                 {
                     OnImageError("Error: Width must be between 0 and 2047");
                 }
                 else
                 {
                     _width = value;
                 }
             }
         }

         public int Height
         {
             get
             {
                 return _height;
             }
             set
             {
                 if (_init)
                 {
                     OnImageError("Error: Cannot change Height after the EditableImage has been initialized");
                 }
                 else if ((value <= ) || (value > ))
                 {
                     OnImageError("Error: Height must be between 0 and 2047");
                 }
                 else
                 {
                     _height = value;
                 }
             }
         }

         public void SetPixel(int col, int row, Color color)
         {
             SetPixel(col, row, color.R, color.G, color.B, color.A);
         }

         public void SetPixel(int col, int row, byte red, byte green, byte blue, byte alpha)
         {
             if (!_init)
             {
                 _rowLength = _width *  + ;
                 _buffer = new byte[_rowLength * _height];

                 // Initialize
                 for (int idx = ; idx < _height; idx++)
                 {
                     _buffer[idx * _rowLength] = ;      // Filter bit
                 }

                 _init = true;
             }

             if ((col > _width) || (col < ))
             {
                 OnImageError("Error: Column must be greater than 0 and less than the Width");
             }
             else if ((row > _height) || (row < ))
             {
                 OnImageError("Error: Row must be greater than 0 and less than the Height");
             }

             // Set the pixel
             int start = _rowLength * row + col *  + ;
             _buffer[start] = red;
             _buffer[start + ] = green;
             _buffer[start + ] = blue;
             _buffer[start + ] = alpha;
         }

         public Color GetPixel(int col, int row)
         {
             if ((col > _width) || (col < ))
             {
                 OnImageError("Error: Column must be greater than 0 and less than the Width");
             }
             else if ((row > _height) || (row < ))
             {
                 OnImageError("Error: Row must be greater than 0 and less than the Height");
             }

             Color color = new Color();
             int _base = _rowLength * row + col + ;

             color.R = _buffer[_base];
             color.G = _buffer[_base + ];
             color.B = _buffer[_base + ];
             color.A = _buffer[_base + ];

             return color;
         }

         public Stream GetStream()
         {
             Stream stream;

             if (!_init)
             {
                 OnImageError("Error: Image has not been initialized");
                 stream = null;
             }
             else
             {
                 stream = PngEncoder.Encode(_buffer, _width, _height);
             }

             return stream;
         }

         private void OnImageError(string msg)
         {
             if (null != ImageError)
             {
                 EditableImageErrorEventArgs args = new EditableImageErrorEventArgs();
                 args.ErrorMessage = msg;
                 ImageError(this, args);
             }
         }

         public class EditableImageErrorEventArgs : EventArgs
         {
             private string _errorMessage = string.Empty;

             public string ErrorMessage
             {
                 get { return _errorMessage; }
                 set { _errorMessage = value; }
             }
         }

     }
 # endregion

 # region Class PngEncoder
     public class PngEncoder
     {
         private const int _ADLER32_BASE = ;
         private const int _MAXBLOCK = 0xFFFF;
         private static byte[] _HEADER = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
         private static byte[] _IHDR = { (byte)'I', (byte)'H', (byte)'D', (byte)'R' };
         private static byte[] _GAMA = { (byte)'g', (byte)'A', (byte)'M', (byte)'A' };
         private static byte[] _IDAT = { (byte)'I', (byte)'D', (byte)'A', (byte)'T' };
         private static byte[] _IEND = { (byte)'I', (byte)'E', (byte)'N', (byte)'D' };
         private static byte[] _4BYTEDATA = { , , ,  };
         private static byte[] _ARGB = { , , , , , , , , , , , ,  };

         public static Stream Encode(byte[] data, int width, int height)
         {
             MemoryStream ms = new MemoryStream();
             byte[] size;

             // Write PNG header
             ms.Write(_HEADER, , _HEADER.Length);

             size = BitConverter.GetBytes(width);
             _ARGB[] = size[]; _ARGB[] = size[]; _ARGB[] = size[]; _ARGB[] = size[];

             size = BitConverter.GetBytes(height);
             _ARGB[] = size[]; _ARGB[] = size[]; _ARGB[] = size[]; _ARGB[] = size[];

             // Write IHDR chunk
             WriteChunk(ms, _IHDR, _ARGB);

             // Set gamma = 1
             size = BitConverter.GetBytes( * );
             _4BYTEDATA[] = size[]; _4BYTEDATA[] = size[]; _4BYTEDATA[] = size[]; _4BYTEDATA[] = size[];

             // Write gAMA chunk
             WriteChunk(ms, _GAMA, _4BYTEDATA);

             // Write IDAT chunk
             uint widthLength = (uint)(width * ) + ;
             uint dcSize = widthLength * (uint)height;

             uint adler = ComputeAdler32(data);
             MemoryStream comp = new MemoryStream();

             // Calculate number of 64K blocks
             uint rowsPerBlock = _MAXBLOCK / widthLength;
             uint blockSize = rowsPerBlock * widthLength;
             uint blockCount;
             ushort length;
             uint remainder = dcSize;

             if ((dcSize % blockSize) == )
             {
                 blockCount = dcSize / blockSize;
             }
             else
             {
                 blockCount = (dcSize / blockSize) + ;
             }

             // Write headers
             comp.WriteByte(0x78);
             comp.WriteByte(0xDA);

             for (uint blocks = ; blocks < blockCount; blocks++)
             {
                 // Write LEN
                 length = (ushort)((remainder < blockSize) ? remainder : blockSize);

                 if (length == remainder)
                 {
                     comp.WriteByte(0x01);
                 }
                 else
                 {
                     comp.WriteByte(0x00);
                 }

                 comp.Write(BitConverter.GetBytes(length), , );

                 // Write one's compliment of LEN
                 comp.Write(BitConverter.GetBytes((ushort)~length), , );

                 // Write blocks
                 comp.Write(data, (int)(blocks * blockSize), length);

                 // Next block
                 remainder -= blockSize;
             }

             WriteReversedBuffer(comp, BitConverter.GetBytes(adler));
             comp.Seek(, SeekOrigin.Begin);

             byte[] dat = new byte[comp.Length];
             comp.Read(dat, , (int)comp.Length);

             WriteChunk(ms, _IDAT, dat);

             // Write IEND chunk
             WriteChunk(ms, _IEND, new byte[]);

             // Reset stream
             ms.Seek(, SeekOrigin.Begin);

             return ms;
         }

         private static void WriteReversedBuffer(Stream stream, byte[] data)
         {
             int size = data.Length;
             byte[] reorder = new byte[size];

             for (int idx = ; idx < size; idx++)
             {
                 reorder[idx] = data[size - idx - ];
             }
             stream.Write(reorder, , size);
         }

         private static void WriteChunk(Stream stream, byte[] type, byte[] data)
         {
             int idx;
             int size = type.Length;
             byte[] buffer = new byte[type.Length + data.Length];

             // Initialize buffer
             for (idx = ; idx < type.Length; idx++)
             {
                 buffer[idx] = type[idx];
             }

             for (idx = ; idx < data.Length; idx++)
             {
                 buffer[idx + size] = data[idx];
             }

             // Write length
             WriteReversedBuffer(stream, BitConverter.GetBytes(data.Length));

             // Write type and data
             stream.Write(buffer, , buffer.Length);   // Should always be 4 bytes

             // Compute and write the CRC
             WriteReversedBuffer(stream, BitConverter.GetBytes(GetCRC(buffer)));
         }
         private static uint[] _crcTable = new uint[];
         private static bool _crcTableComputed = false;
         private static void MakeCRCTable()
         {
             uint c;
             for (int n = ; n < ; n++)
             {
                 c = (uint)n;
                 for (int k = ; k < ; k++)
                 {
                     if ((c & (0x00000001)) > )
                         c = 0xEDB88320 ^ (c >> );
                     else
                         c = c >> ;
                 }
                 _crcTable[n] = c;
             }

             _crcTableComputed = true;
         }
         private static uint UpdateCRC(uint crc, byte[] buf, int len)
         {
             uint c = crc;

             if (!_crcTableComputed)
             {
                 MakeCRCTable();
             }

             for (int n = ; n < len; n++)
             {
                 c = _crcTable[(c ^ buf[n]) & 0xFF] ^ (c >> );
             }

             return c;
         }
         private static uint GetCRC(byte[] buf)
         {
             return UpdateCRC(0xFFFFFFFF, buf, buf.Length) ^ 0xFFFFFFFF;
         }
         private static uint ComputeAdler32(byte[] buf)
         {
             uint s1 = ;
             uint s2 = ;
             int length = buf.Length;

             for (int idx = ; idx < length; idx++)
             {
                 s1 = (s1 + (uint)buf[idx]) % _ADLER32_BASE;
                 s2 = (s2 + s1) % _ADLER32_BASE;
             }
             return (s2 << ) + s1;
         }
     }
 # endregion
 //* -------------------------------------------------------------------------------------------------
 //* -------------------------------------------------------------------------------------------------