C#

  if (HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"] != null)
            {
                //To get the IP address of the machine and not the proxy
                m_IPAddress = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString();
            }
            else if (HttpContext.Current.Request.UserHostAddress.Length != 0)
            {
                m_IPAddress = HttpContext.Current.Request.UserHostAddress;
            }
            DataTable dt = GetLocation(m_IPAddress);
            if (dt != null)
            {
                if (dt.Rows.Count > 0)
                {
                     m_IPCountry = dt.Rows[0]["City"].ToString() + "," + dt.Rows[0]["RegionName"].ToString() + "," + dt.Rows[0]["CountryName"].ToString() + "," + dt.Rows[0]["CountryCode"].ToString();
                }
                else
                {
                }
            } 
private DataTable GetLocation(string ipaddress)
        {

            //Create a WebRequest 

            WebRequest rssReq = WebRequest.Create("http://freegeoip.appspot.com/xml/" + ipaddress);
            //Create a Proxy 
            WebProxy px = new WebProxy("http://freegeoip.appspot.com/xml/" + ipaddress, true);
            //Assign the proxy to the WebRequest 
            rssReq.Proxy = px;
            //Set the timeout in Seconds for the WebRequest 
            rssReq.Timeout = 2000;
            try
            {
                //Get the WebResponse 
                WebResponse rep = rssReq.GetResponse();
                //Read the Response in a XMLTextReader 
                XmlTextReader xtr = new XmlTextReader(rep.GetResponseStream());
                //Create a new DataSet 
                DataSet ds = new DataSet();
                //Read the Response into the DataSet 
                ds.ReadXml(xtr);
                return ds.Tables[0];
            }

            catch
            {
                return null;
            }
        }

CspParameters csp      = new CspParameters();
csp.Flags              = CspProviderFlags.UseMachineKeyStore |
                         CspProviderFlags.UseNonExportableKey;
csp.KeyContainerName   = "Example Container Name";
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(1024, csp);

1) Load an asymmetric algorithm (RSACryptoServiceProvider) stored using a CspParameters object
2) Create a symmetric algorithm object (AesCryptoServiceProvider)
3) Encrypt the concatenated key and initialization vector using the RSA encryptor
4) Create a new MemoryStream object (with associated BinaryWriter)
5) Write the following data to the output stream:
   *The size of the encrypted key/IV vector
   *The encrypted key/IV vector
6) Create new CryptoStream and BinaryWriter objects and write my data to the MemoryStream
7) Hash the MemoryStream, and sign the hash
8) Open a file for writing (FileStream)
9) Write the following data
   *Length of the signed hash
   *The signed hash
   *COPY THE CONTENTS OF THE MEMORY STREAM TO THE OUTPUT

class ExampleForm : Form {
    private readonly int                      m_SymmetricKeySize = s_KeySizeSym >> 3;
    private readonly int                      m_SymmetricBlockSize;
    private readonly RSACryptoServiceProvider m_AsymmetricAlg;
    private readonly SymmetricAlgorithm       m_SymmetricAlg = new AesCryptoServiceProvider();
    private readonly HashAlgorithm            m_HashAlg      = new MD5CryptoServiceProvider();
    private readonly string                   m_OutFile      =
        Path.Combine(Application.CommonAppDataPath, "Example.dat");

    private static void CopyStream(Stream src, Stream dst) {
        const int bufferSize = 256;
        byte[]    buffer     = new byte[bufferSize];
        int count;
        do {
            count = src.Read(buffer, 0, bufferSize);
            dst.Write(buffer, 0, count);
        } while (count == bufferSize);
    }

    public ExampleForm() {
        // Create the cryptographic data members
        m_SymmetricBlockSize   = m_SymmetricAlg.BlockSize >> 3;
        CspParameters csp      = new CspParameters();
        csp.KeyContainerName   = "Example Container";
        m_AsymmetricAlg        = new RSACryptoServiceProvider(2048, csp);

        // Load the encrypted file
        bool isFileValid = File.Exists(m_OutFile);
        if (isFileValid) {
            // Open the input file, and create a temporary memory stream
            Stream       dataStream   = new MemoryStream();
            Stream       fileStream   = File.OpenRead(m_OutFile);
            BinaryReader binaryReader = new BinaryReader(fileStream);

            // Read the signature
            byte[] sign = new byte[binaryReader.ReadInt32()];
            fileStream.Read(sign, 0, sign.Length);

            // Copy the remaining contents to another stream
            ExampleForm.CopyStream(fileStream, dataStream);

            // Close the input file
            binaryReader.Close();
            fileStream  .Close();

            // Compute and verify the hash value of the new stream
            byte[] hash = m_HashAlg.ComputeHash(dataStream);
            isFileValid = m_AsymmetricAlg.VerifyHash(hash,
                          CryptoConfig.MapNameToOID("MD5"), sign);

            if (isFileValid) {
                // Create the necessary input streams
                dataStream.Seek(0, SeekOrigin.Begin);
                binaryReader = new BinaryReader(dataStream);

                // Load the key and IV vectors
                byte[] encKeyIV = new byte[binaryReader.ReadInt32()];
                dataStream.Read(encKeyIV, 0, encKeyIV.Length);
                byte[] keyAndIV = new byte[m_SymmetricBlockSize + m_SymmetricKeySize];
                keyAndIV = m_AsymmetricAlg.Decrypt(encKeyIV, true);

                // Copy the key and IV to the symmetric algorithm members
                byte[] key = new byte[m_SymmetricKeySize  ];
                byte[] iv  = new byte[m_SymmetricBlockSize];
                for (int idx = 0; idx < m_SymmetricKeySize; ++idx)
                    key[idx] = keyAndIV[idx];
                for (int idx = 0; idx < m_SymmetricBlockSize; ++idx)
                    iv [idx] = keyAndIV[idx + m_SymmetricKeySize];

                // Create the streams for outputting data
                CryptoStream cryptoStream = new CryptoStream(dataStream,
                    m_SymmetricAlg.CreateDecryptor(key, iv), CryptoStreamMode.Read);
                BinaryReader cryptoReader = new BinaryReader(cryptoStream);

                // Read the data, utilizing...
                //   cryptoReader.ReadUInt32();
                //   cryptoReader.ReadString();
                //   cryptoReader.ReadInt64 ();

                // Close the appropriate data streams
                binaryReader.Close();
                cryptoReader.Close();
                cryptoStream.Close();
            } else {
                // The file is corrupt
            }

            // Close the data stream
            dataStream.Close();
        }
    }

    private void ExampleForm_FormClosing(object sender, FormClosingEventArgs e) {
        // Create an array containing the symmetric key and initialization vector
        byte[] keyAndIV = new byte[m_SymmetricBlockSize + m_SymmetricKeySize];
        m_SymmetricAlg.Key.CopyTo(keyAndIV, 0);
        m_SymmetricAlg.IV .CopyTo(keyAndIV, m_SymmetricKeySize);

        // Create the temporary output objects
        Stream       dataStream   = new MemoryStream();
        BinaryWriter binaryWriter = new BinaryWriter(dataStream);
        BinaryWriter cryptoWriter = new BinaryWriter(new CryptoStream(
            dataStream, m_SymmetricAlg.CreateEncryptor(), CryptoStreamMode.Write));

        // Encrypt and write the symmetric key and IV using the asymmetric algorithm
        byte[] encKeyIV = m_AsymmetricAlg.Encrypt(keyAndIV, true);
        binaryWriter.Write(encKeyIV.Length);
        binaryWriter.Flush();
        dataStream.Write(encKeyIV, 0, encKeyIV.Length);


        // Encrypt and write the data utilizing...
        //     cryptoWriter.Write(uint);
        //     cryptoWriter.Write(string);
        //     cryptoWriter.Write(long);
        cryptoWriter.Flush();

        // Compute and sign the hash code for the file
        byte[] hash = m_HashAlg.ComputeHash(dataStream);
        byte[] sign = m_AsymmetricAlg.SignHash(hash, CryptoConfig.MapNameToOID(s_HashName));

#region Option 1 (What I would like to do)
        Stream fileStream = File.OpenWrite(m_OutFile);
        binaryWriter = new BinaryWriter(fileStream);

        // Write the data to the output file
        binaryWriter.Write(sign.Length);
        binaryWriter.Flush();
        fileStream.Write(sign, 0, sign.Length);
        dataStream.Seek(0, SeekOrigin.Begin);
        ExampleForm.CopyStream(dataStream, fileStream);

        // Close the streams
        cryptoWriter.Close();
        binaryWriter.Close();
        fileStream.Close();
        dataStream.Close();
#endregion

#region Option 2 (The option that currently works)
        // Close the streams
        cryptoWriter.Close();
        binaryWriter.Close();
        dataStream  .Close();

        // Create the actual output objects
        Stream fileStream = File.OpenWrite(m_OutFile);
        binaryWriter = new BinaryWriter(fileStream);
        cryptoWriter = new BinaryWriter(new CryptoStream(
            fileStream, m_SymmetricAlg.CreateEncryptor(), CryptoStreamMode.Write));

        // Write the data to the output file
        binaryWriter.Write(sign.Length);
        binaryWriter.Flush();
        fileStream.Write(sign, 0, sign.Length);

        // Rewrite the data already written to the output stream
        binaryWriter.Write(encKeyIV.Length);
        binaryWriter.Flush();
        fileStream.Write(encKeyIV, 0, encKeyIV.Length);

        // Encrypt and write the data utilizing...
        //     cryptoWriter.Write(uint);
        //     cryptoWriter.Write(string);
        //     cryptoWriter.Write(long);

        // Close the output objects
        cryptoWriter.Close();
        binaryWriter.Close();
        fileStream  .Close();
#endregion

    }
}