System.ArithmeticException

This usually occurs if the runtime system of the C dll changes FPU flags. You need to reset those after calling the function similar to this:

[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
extern static uint _controlfp(uint newcw,uint mask);

const uint _MCW_EM=0x0008001f;
const uint _EM_INVALID=0x00000010;

public static void FixFPU() {
{
  _controlfp(_MCW_EM, _EM_INVALID);
}

My guess is that you're running out of memory in the byte[] array.

You can try breaking the file down and reading it in chunks.

I found a code example from a Google search to get you started:

C# file downloader AKA Response.BinaryWrite

using System;
using System.IO;
using System.Web;

public class Download
{
    public static void SmallFile(string filename, string filepath, string contentType)
    {
        try
        {
            FileStream MyFileStream = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
            long FileSize;
            FileSize = MyFileStream.Length;
            byte[] Buffer = new byte[(int)FileSize];
            MyFileStream.Read(Buffer, 0, (int)MyFileStream.Length);
            MyFileStream.Close();
            HttpContext.Current.Response.ContentType = contentType;
            HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8));
            HttpContext.Current.Response.BinaryWrite(Buffer);             
        }
        catch
        {
            HttpContext.Current.Response.ContentType = "text/html";
            HttpContext.Current.Response.Write("Downloading Error!");
        }
        HttpContext.Current.Response.End();
    }

    public static void LargeFile(string filename, string filepath, string contentType)
    {
        Stream iStream = null;
        // Buffer to read 10K bytes in chunk
        //byte[] buffer = new Byte[10000];
        // Buffer to read 1024K bytes in chunk
        byte[] buffer = new Byte[1048576];

        // Length of the file:
        int length;
        // Total bytes to read:
        long dataToRead;

        try
        {
            // Open the file. 
            iStream = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);

            // Total bytes to read:
            dataToRead = iStream.Length;
            HttpContext.Current.Response.ContentType = contentType;
            HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment; filename=" + HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8));

            // Read the bytes.
            while (dataToRead > 0)
            {
                // Verify that the client is connected.
                if (HttpContext.Current.Response.IsClientConnected)
                {
                    // Read the data in buffer.
                    length = iStream.Read(buffer, 0, 10000);

                    // Write the data to the current output stream.
                    HttpContext.Current.Response.OutputStream.Write(buffer, 0, length);

                    // Flush the data to the HTML output.
                    HttpContext.Current.Response.Flush();

                    buffer = new Byte[10000];
                    dataToRead = dataToRead - length;
                }
                else
                {
                    //prevent infinite loop if user disconnects
                    dataToRead = -1;
                }
            }
        }
        catch (Exception ex)
        {
            // Trap the error, if any.
            //HttpContext.Current.Response.Write("Error : " + ex.Message);
            HttpContext.Current.Response.ContentType = "text/html";
            HttpContext.Current.Response.Write("Error : file not found");                 
        }
        finally
        {
            if (iStream != null)
            {
                //Close the file.
                iStream.Close();
            }
            HttpContext.Current.Response.End();
            HttpContext.Current.Response.Close();             
        }         
    }

    public static void ResumableFile(string filename, string fullpath, string contentType)
    {
        try
        {
            FileStream myFile = new FileStream(fullpath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            BinaryReader br = new BinaryReader(myFile);
            try
            {
                HttpContext.Current.Response.AddHeader("Accept-Ranges", "bytes");
                HttpContext.Current.Response.Buffer = false;
                long fileLength = myFile.Length;
                long startBytes = 0;

                //int pack = 10240; //10K bytes
                int pack = 1048576; //1024K bytes

                if (HttpContext.Current.Request.Headers["Range"] != null)
                {
                    HttpContext.Current.Response.StatusCode = 206;
                    string[] range = HttpContext.Current.Request.Headers["Range"].Split(new char[] { '=', '-' });
                    startBytes = Convert.ToInt64(range[1]);
                }
                HttpContext.Current.Response.AddHeader("Content-Length", (fileLength - startBytes).ToString());
                if (startBytes != 0)
                {
                    HttpContext.Current.Response.AddHeader("Content-Range", string.Format(" bytes {0}-{1}/{2}", startBytes, fileLength - 1, fileLength));
                }
                HttpContext.Current.Response.AddHeader("Connection", "Keep-Alive");
                HttpContext.Current.Response.ContentType = contentType;
                HttpContext.Current.Response.AddHeader("Content-Disposition", "attachment;filename=" + HttpUtility.UrlEncode(filename, System.Text.Encoding.UTF8));

                br.BaseStream.Seek(startBytes, SeekOrigin.Begin);
                int maxCount = (int)Math.Floor((double)((fileLength - startBytes) / pack)) + 1;

                for (int i = 0; i < maxCount; i++)
                {
                    if (HttpContext.Current.Response.IsClientConnected)
                    {
                        HttpContext.Current.Response.BinaryWrite(br.ReadBytes(pack));
                    }
                    else
                    {
                        i = maxCount;
                    }
                }
            }
            catch
            {
                HttpContext.Current.Response.ContentType = "text/html";
                HttpContext.Current.Response.Write("Error : file not found");
            }
            finally
            {
                br.Close();
                myFile.Close();
            }
        }
        catch
        {
            HttpContext.Current.Response.ContentType = "text/html";
            HttpContext.Current.Response.Write("Error : file not found");
        }
    }     
}

I am not sure of the root cause yet but the solution is here :
http://social.msdn.microsoft.com/forums/en-US/wpf/thread/a31f9c7a-0e15-4a09-a544-bec07f0f152c

Seems to be a popular bug :)

If it can help, I was having the exact same problem (as stated here and here). I bring here one of the possible CAUSE of this.

I am using a ElementHost (c#, .net4.0, winform, VS2012) for a great WPF UserControl. Everything was working Great. In my UserControl behind-code, I was using a class that was caming from another DLL, used to store progression of certain task. For example (it is close to reality) :

public class SI_MyProgressionHelper
{
    public string gstr_OverallProgress_Description { get; set; }

    public int gint_OverallProgress_ActualValue { get; set; }
    public int gint_OverallProgress_MaximumValue { get; set; }
}

I then wanted to "plug" that class into my WPF progressBar/textBox to report the progression as it goes. However (and that's another conversation), WPF needs to have INotifyPropertyChanged applied to every single property you want to plug in WPF (to automatically update controls in WPF). That's one of the ugliest thing I ever saw, but it is what it is (And I know i must missed something..)

Anyway, to complies to WPF Binding mecanism between my ProgressBar/textbox and my SI_MyProgressionHelper class, i've modified the class (which I repeat, is in another DLL) to this :

public class SI_MyProgressionHelper : INotifyPropertyChanged
{
    private string _gstr_OverallProgress_Description = "";
    public string gstr_OverallProgress_Description { get { return _gstr_OverallProgress_Description; } set { _gstr_OverallProgress_Description = value; RaisePropertyChanged("gstr_OverallProgress_Description"); } }   

    private int _gint_OverallProgress_ActualValue = 0;
    public int gint_OverallProgress_ActualValue { get { return _gint_OverallProgress_ActualValue; } set { _gint_OverallProgress_ActualValue = value; RaisePropertyChanged("gint_OverallProgress_ActualValue"); } }   

    private int _gint_OverallProgress_MaximumValue = 9999;
    public int gint_OverallProgress_MaximumValue { get { return _gint_OverallProgress_MaximumValue; } set { _gint_OverallProgress_MaximumValue = value; RaisePropertyChanged("gint_OverallProgress_MaximumValue"); } }   


    protected virtual void RaisePropertyChanged(string propName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propName));
    }
    public event PropertyChangedEventHandler PropertyChanged;
}

BAM! The error occurs on any random integer property of any XMLElement (Height, Width, etc...) of my UserContrl (exactly as stated here and in the other reference I stated at the top).

Applying the solution brought here does correct my problem : In my Program.cs Main() method :

[DllImport( "msvcr70.dll", CallingConvention = CallingConvention.Cdecl )]
public static extern int _fpreset();

and then, in my UserControl.xaml.cs, in the constructor :

public UserControl1()
{
    Program._fpreset(); 
    InitializeComponent();
} 

Also, and that's the reason why I wrote that comment : by removing the INotifyPropertyChanged on my Helper class (and other stuff related), the problem goes away. (but my WPF is sad because my code is too short for him).

Hope this additionnal information may help someone having the same problem.

Also, for all my french colleague, here is the french error encountered :

Il y a eu un dépassement de capacité positif ou négatif dans l'opération arithmétique.