using System;
  using System.IO;
  using System.Windows;
  using System.Windows.Media;
  using System.Windows.Media.Imaging; 
  [...]

  private System.Windows.Controls.InkCanvas m_inkCanvas;
  [...]

  // ---------------------------------------------------------------
  // Date      211007
  // Purpose   Public Method - Save the InkCanvas StrokeCollection to file as ISF.
  // Entry     oBB - Current brush for InkCanvas backgound color. 
  //           Use Property BrushBack.
  //           sFileName_out - Filename to save (+ path).
  // Return    The saved bitmap saved, null if not successful.
  // Comments  1) Uses m_inkCanvas, the InkCanvas control.
  //           2) The image is saved with current backgound color. 
  // ---------------------------------------------------------------
  public bool SaveInkAsBitmap(SolidColorBrush oBB, string sFileName_out)
  {
      try
      {
          // 1) Use bounding rectangle from strokes as outer size of image.
          Rect recBounds = m_inkCanvas.Strokes.GetBounds();

          /*
          // 2) Use size of canvas. Depends on user resizing window in GUI.
          Rect recBounds = new Rect();
          recBounds.X = 0;
          recBounds.Y = 0;
          recBounds.Width = m_inkCanvas.Width;
          recBounds.Height = m_inkCanvas.Height;
          */

          DrawingVisual dVisual = new DrawingVisual();
          DrawingContext dContext = dVisual.RenderOpen();
          dContext.PushTransform(new TranslateTransform(-recBounds.X, -recBounds.Y));

          // Default background color is transparent.
          // Use white when the file format does not support transparency.
          if (oBB == null)
          {
              oBB = Brushes.White;
          }
          dContext.DrawRectangle(oBB, null, recBounds);
          m_inkCanvas.Strokes.Draw(dContext);
          dContext.Close();

          RenderTargetBitmap oBitmap =
              new RenderTargetBitmap((int)recBounds.Width,
              (int)recBounds.Height,
              96, 96, PixelFormats.Default);
          oBitmap.Render(dVisual);

          // Use bitmapencoder depending on file-extension from user.
          BitmapEncoder oEncoder = null;
          switch (Path.GetExtension(sFileName_out))
          {
              case ".bmp":
                  oEncoder = new BmpBitmapEncoder();
                  iBitmapSelect = 1;
                  break;
              case ".jpg":
                  oEncoder = new JpegBitmapEncoder();
                  iBitmapSelect = 2;
                  break;
              case ".png":
                  oEncoder = new PngBitmapEncoder();
                  iBitmapSelect = 3;
                  break;
              case ".gif":
                  oEncoder = new GifBitmapEncoder();
                  iBitmapSelect = 4;
                  break;
              case ".tif":
                  oEncoder = new TiffBitmapEncoder();
                  iBitmapSelect = 5;
                  break;
              case ".wmp":
                  oEncoder = new WmpBitmapEncoder();
                  iBitmapSelect = 6;
                  break;
              default:
                  iBitmapSelect = 3;
                  // sRet = "This file extension is not supported.";
                  break;
          }

          if (oEncoder != null)
          {
              oEncoder.Frames.Add(BitmapFrame.Create(oBitmap));
              if (File.Exists(sFileName_out) == true)
              {
                  File.SetAttributes(sFileName_out, FileAttributes.Normal);
              }
              using (FileStream fs = File.Create(sFileName_out))
              {
                  oEncoder.Save(fs);
              }
          }
          return true;
      }
      catch
      {
          return false;
      }
  }

  private System.Windows.Media.SolidColorBrush m_brushBack;
  m_brushBack = Brushes.White;
  [...]
  int iBitmapSelect = 3;	// png.
  [...]

  // Menu File - Save Ink as Bitmap.
  private void mnuFileSaveAsBitmap_Click(object sender, RoutedEventArgs e)
  {
      SaveFileDialog saveFileDialog1 = new SaveFileDialog();
      saveFileDialog1.Filter =
          "Windows Bitmap (*.bmp)|*.bmp|" +
          "JPEG (*.jpg)|*.jpg|" +
          "Portable Network Graphics (*.png)|*.png|" +
          "CompuServe Graphics Interchange (*.gif)|*.gif|" +
          "Tagged Image File Format (*.tif)|*.tif|" +
          "Windows Media Photo (*.wmp)|*.wmp";
      saveFileDialog1.FilterIndex = iBitmapSelect;    // 1-based.
      if (saveFileDialog1.ShowDialog() == DialogResult.OK)
      {
          bool bRet = SaveInkAsBitmap(m_brushBack, saveFileDialog1.FileName);
          if (bRet == false)
          {
              System.Windows.MessageBox.Show("Error saving Ink as Bitmap.", "Error");
          }
      }
      saveFileDialog1.Dispose();
  }

  using System;
  using System.IO;
  [...]

  // ---------------------------------------------------------------
  // Date      300509
  // Purpose   Public Method - Convert a StrokeCollection to a Base64 text.
  // Entry     inkStrokes - A collection of Strokes, use m_inkCanvas.Strokes.
  // Return    The StrokeCollection as Base64 text.
  // Comments  1) Background color is not saved.
  //           2) The Base64 code is returned in lines with max 76 characters each.
  // ---------------------------------------------------------------
  public string StrokesToBase64(StrokeCollection inkStrokes)
  {
      try
      {
          using (MemoryStream ms = new MemoryStream())
          {
              // Save strokes from InkCanvas to a stream as ISF.
              inkStrokes.Save(ms);
              // Convert bytes from stream to Base64 text.
              byte[] isfBytes = ms.ToArray();
              return Convert.ToBase64String(isfBytes, 
                     Base64FormattingOptions.InsertLineBreaks);
          }
      }
      catch
      {
          return "";
      }
  }

  
  AIIDAxdIEUTfvIIFRYQBGwIAJAFGhAEbAgAkAREAAIA/HwkRAAAAAAAA8D8KKRCH8ElHgjzms1mc
  0mQtEymc1gEBh/CkN4Uu7Nh7Dlos9rw6tKawCazIChgHh/BYJ4LOZkTKAIfwk7eE7W0TOzYetAAK
  NRSH8HRHg5TmqawCZTW1WaaTKZ4fmaZzIIfwlweEuHDmHsOTLDev7PonDrDmht5WiA5Rw7awCikQ
  h/Cxd4WLy0pnZpoyktFptM1Ah/B3l4OiVm0VoRoXgKcO5Tw6ylZpsAoaCIfwwFeGD+a2hMrVa4fw
  pDeE32YQC04fw6AKFQaH8N4XhvDmk1CH8KyHhUpmMBgFrAojDIfweueEJu0Ye0NwEmVMP6J0LayH
  8O6nhzNs+H7TaWHLVNQKWCmH8OMXhwvw9aEBs+HYDNGH7PMkzmRNJlaLNAJpa7TALXM4BAZlAJlN
  ZpM5kIfwsXeFi9NYAgMAmRNYBAZmtFpmkymcyw4mc0tczmkwxBa1ngMzmkyTWzg=

  using System;
  using System.IO;
  [...]

  // ---------------------------------------------------------------
  // Date      300509
  // Purpose   Public Method - Convert a Base64 text to a StrokeCollection.
  // Entry     sBase64 - The Base64 text.
  // Return    A StrokeCollection. Returns null when not successful.
  // Comments  1) Use StrokesToBase64() to make a StrokeCollection as Base64.
  //           2) Use InkCanvas.Strokes = StrokesFromBase64(Base64-text)
  //           for showing the strokes in the InkCanvas Control.
  // ---------------------------------------------------------------
  public StrokeCollection Base64ToStrokes(string sBase64)
  {
      try
      {
          StrokeCollection sc = null;
          // Base64 to byte-array.
          byte[] isfBytes = Convert.FromBase64String(sBase64);
          // Save to a stream.
          using (MemoryStream ms = new MemoryStream())
          {
              ms.Write(isfBytes, 0, isfBytes.Length);
              ms.Position = 0;     // Wind back.
              // Get StrokeCollection from stream.
              sc = new StrokeCollection(ms);
          }
          return sc;
      }
      catch
      {
          return null;
      }
  }

 InkCanvas m_inkCanvas = new InkCanvas();
 string sBase64;  // Contains StrokeCollection as Base64.
 [...]
 StrokeCollection sc = StrokesFromBase64(sBase64);
 m_inkCanvas.Strokes = sc;