JohnnyCoder » Code Library

.NET MailMessage, LinkedResources, AlternateViews and Exceptions

Ben Griswold — Thu, 16 Apr 2009 05:05:34 +0000

It doesn’t take much to hack together email functionality using the .NET framework. In most cases you can new-up a MailMessage reference, assign sender and recipient addresses, provide a subject and a message body, configure your SMTP settings and then send. Done and done.

But let’s say you need to provide both plain text and HTML versions of your message body. Or maybe you would like to embed an image or two within the message body. Or, what if, for some reason, you actually want to handle exceptions appropriately. Well, there’s more to it then.

There are a numerous ways to better organize the following code. In fact, we just went through an exercise at work where we refactored the heck out of the core email functionality and produce a really clean usable component which can be easily mocked, configured and leverages email templates. It’s pretty cool. That being said, I believe the following sample demonstrates the aforementioned core features of .NET emailing.

I hope it helps. Let me know if I missed anything or it the example could be more clear.

try
{
    // Assign a sender, recipient and subject to new mail message
    MailAddress sender =
        new MailAddress("sender@johnnycoder.com", "Sender");

    MailAddress recipient =
        new MailAddress("recipient@johnnycoder.com", "Recipient");

    MailMessage m = new MailMessage(sender, recipient);
    m.Subject = "Test Message";

    // Define the plain text alternate view and add to message
    string plainTextBody =
        "You must use an email client that supports HTML messages";

    AlternateView plainTextView =
        AlternateView.CreateAlternateViewFromString(
            plainTextBody, null, MediaTypeNames.Text.Plain);

    m.AlternateViews.Add(plainTextView);

    // Define the html alternate view with embedded image and
    // add to message. To reference images attached as linked
    // resources from your HTML message body, use "cid:contentID"
    // in the  tag...
    string htmlBody =
        "Picture

" +
        "";

    AlternateView htmlView =
        AlternateView.CreateAlternateViewFromString(
            htmlBody, null, MediaTypeNames.Text.Html);

    // ...and then define the actual LinkedResource matching the
    // ContentID property as found in the image tag. In this case,
    // the HTML message includes the tag
    //  and the following
    // LinkedResource.ContentId is set to "SampleImage"
    LinkedResource sampleImage =
        new LinkedResource("sample.jpg",
            MediaTypeNames.Image.Jpeg);
    sampleImage.ContentId = "SampleImage";

    htmlView.LinkedResources.Add(sampleImage);

    m.AlternateViews.Add(htmlView);

    // Finally, configure smtp or alternatively use the
    // system.net mailSettings
    SmtpClient smtp = new SmtpClient
          {
              Host = "smtp.bigcompany.com",
              UseDefaultCredentials = false,
              Credentials =
                  new NetworkCredential("username", "password")
          };

    //
    //    
    //        
    //            
    //        
    //    
    //

    smtp.Send(m);
}
catch (ArgumentException)
{
    throw new
        ArgumentException("Undefined sender and/or recipient.");
}
catch (FormatException)
{
    throw new
        FormatException("Invalid sender and/or recipient.");
}
catch (InvalidOperationException)
{
    throw new
        InvalidOperationException("Undefined SMTP server.");
}
catch (SmtpFailedRecipientException)
{
    throw new SmtpFailedRecipientException(
        "The mail server says that there is no mailbox for recipient");
}
catch (SmtpException ex)
{
    // Invalid hostnames result in a WebException InnerException that
    // provides a more descriptive error, so get the base exception
    Exception inner = ex.GetBaseException();
    throw new SmtpException("Could not send message: " + inner.Message);
}

C# Cache Helper Class Revisited

Ben Griswold — Fri, 12 Dec 2008 17:57:38 +0000

The Cache Helper Class has been updated so that it is no longer limited by the generic constraint. The original post has been updated along with a sample project for

download. Let me know what think. I know I’m much happy with this solution. As always, thanks for your comments and thanks for letting me take a mulligan.

C# Cache Helper Class

Ben Griswold — Wed, 10 Dec 2008 18:14:24 +0000

Do you need a quick and cache wrapper class? Here’s a static class which I included in my more recent C# web application. You’ll notice the class uses generics to allow for some, umm, generic functionality.

public static class CacheHelper
{
    /// 
    /// Insert value into the cache using
    /// appropriate name/value pairs
    /// 
    /// Type of cached item
    /// Item to be cached
    /// Name of item
    public static void Add(T o, string key) where T : class
    {
        // NOTE: Apply expiration parameters as you see fit.
        // In this example, I want an absolute
        // timeout so changes will always be reflected
        // at that time. Hence, the NoSlidingExpiration.
        HttpContext.Current.Cache.Insert(
            key,
            o,
            null,
            DateTime.Now.AddMinutes(
                ConfigurationHelper.CacheExpirationMinutes),
            System.Web.Caching.Cache.NoSlidingExpiration);
    }

    /// 
    /// Remove item from cache
    /// 
    /// Name of cached item
    public static void Clear(string key)
    {
        HttpContext.Current.Cache.Remove(key);
    }

    /// 
    /// Check for item in cache
    /// 
    /// Name of cached item
    /// 
    public static bool Exists(string key)
    {
        return HttpContext.Current.Cache[key] != null;
    }

    /// 
    /// Retrieve cached item
    /// 
    /// Type of cached item
    /// Name of cached item
    /// Cached item as type
    public static T Get(string key) where T : class
    {
        try
        {
            return (T) HttpContext.Current.Cache[key];
        }
        catch
        {
            return null;
        }
    }
}

And here is a relatively standard sample usage of the library.

public override List<Employee> GetEmployeeList()
{
    string key = ConfigurationHelper.CacheKeyEmployeeList;

    List<Employee> employees = CacheHelper.Get<List<Employee>>(key);

    if (employees == null)
    {
        employees = instance.GetEmployeeList();
        CacheHelper.Add(employees, key);
    }

    return employees;
}

Notice how I’m grabbing the cached value, storing it in a local variable and then checking if it is equal to null rather than using the CacheHelper.Exists() method. If I used the CacheHelper.Exists() method, the cached object could expire between the time I check its existence and the time I get its value through the CacheHelper.Get() method. Therefore, the above approach is the safest strategy to use when retrieving cached values. CacheHelper.Exists() should really only be used for quick existence checks which are unrelated to the fetch.

But if you want to use the code CORRECTLY there’s a catch. Did you notice the “class” constraint on the CacheHelper.Get() and CacheHelper.Add() methods? I did this because you can’t always return null from a generic method. If the return type were always a reference type it would be fine, but comparing a non-nullable value type to null would throw a runtime exception or would always evaluate to false. Therefore, I’ve constrainted CacheHelper which limits its functionality but unsure safe use of the cache. If you’re feeling dangerous, you’re welcome to remove the constraints.

I’ll update the library once I come up with a good work around. Speaking of, any suggestions?

Let me know if you have any questions and/or this type of post is helpful. Thanks.

UPDATE 12/10:

After further review, I’ve removed the “class” constraint from the CacheHelper. The Get() method now follows the common Try(x, out y) pattern where x is what you wish to operate on, y is the resulting value and the method return success or failure. Here’s a sample call:

string key = "EmployeeList";
List<Employee> employees;

if (!CacheHelper.Get(key, out employees))
{
    employees = DataAccess.GetEmployeeList();
    CacheHelper.Add(employees, key);
    Message.Text =
        "Employees not found but retrieved and added to cache for next lookup.";
}
else
{
    Message.Text = "Employees pulled from cache.";
}

And here’s the updated class. Note, I’ve also provided a sample project for download. Thanks for your comments!

using System;
using System.Web;

public static class CacheHelper
{
    /// 
    /// Insert value into the cache using
    /// appropriate name/value pairs
    /// 
    /// Type of cached item
    /// Item to be cached
    /// Name of item
    public static void Add(T o, string key)
    {
        // NOTE: Apply expiration parameters as you see fit.
        // I typically pull from configuration file.

        // In this example, I want an absolute
        // timeout so changes will always be reflected
        // at that time. Hence, the NoSlidingExpiration.
        HttpContext.Current.Cache.Insert(
            key,
            o,
            null,
            DateTime.Now.AddMinutes(1440),
            System.Web.Caching.Cache.NoSlidingExpiration);
    }

    /// 
    /// Remove item from cache
    /// 
    /// Name of cached item
    public static void Clear(string key)
    {
        HttpContext.Current.Cache.Remove(key);
    }

    /// 
    /// Check for item in cache
    /// 
    /// Name of cached item
    /// 
    public static bool Exists(string key)
    {
        return HttpContext.Current.Cache[key] != null;
    }

    /// 
    /// Retrieve cached item
    /// 
    /// Type of cached item
    /// Name of cached item
    /// Cached value. Default(T) if
    /// item doesn't exist.
    /// Cached item as type
    public static bool Get(string key, out T value)
    {
        try
        {
            if (!Exists(key))
            {
                value = default(T);
                return false;
            }

            value =  (T) HttpContext.Current.Cache[key];
        }
        catch
        {
            value = default(T);
            return false;
        }

        return true;
    }
}

Download CacheHelper Sample Project:CacheHelperClass.zip

C# Encryption / Decryption Helper Class

Ben Griswold — Fri, 04 Jul 2008 06:09:30 +0000

I have collected a reasonably good size library of C# helper files over the years. The EncryptionHelper below is one of many which I plan to share.

using System;
using System.Security.Cryptography;
using System.Text;

namespace Common
{
    public static class EncryptionHelper
    {
        private const string cryptoKey = "cryptoKey";

        // The Initialization Vector for the DES encryption routine
        private static readonly byte[] IV =
            new byte[8] { 240, 3, 45, 29, 0, 76, 173, 59 };

        /// 
        /// Encrypts provided string parameter
        /// 
        public static string Encrypt(string s)
        {
            if (s == null || s.Length == 0) return string.Empty;

            string result = string.Empty;

            try
            {
                byte[] buffer = Encoding.ASCII.GetBytes(s);

                TripleDESCryptoServiceProvider des =
                    new TripleDESCryptoServiceProvider();

                MD5CryptoServiceProvider MD5 =
                    new MD5CryptoServiceProvider();

                des.Key =
                    MD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(cryptoKey));

                des.IV = IV;
                result = Convert.ToBase64String(
                    des.CreateEncryptor().TransformFinalBlock(
                        buffer, 0, buffer.Length));
            }
            catch
            {
                throw;
            }

            return result;
        }

        /// 
        /// Decrypts provided string parameter
        /// 
        public static string Decrypt(string s)
        {
            if (s == null || s.Length == 0) return string.Empty;

            string result = string.Empty;

            try
            {
                byte[] buffer = Convert.FromBase64String(s);

                TripleDESCryptoServiceProvider des =
                    new TripleDESCryptoServiceProvider();

                MD5CryptoServiceProvider MD5 =
                    new MD5CryptoServiceProvider();

                des.Key =
                    MD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(cryptoKey));

                des.IV = IV;

                result = Encoding.ASCII.GetString(
                    des.CreateDecryptor().TransformFinalBlock(
                    buffer, 0, buffer.Length));
            }
            catch
            {
                throw;
            }

            return result;
        }
    }
}

You may have noticed that my recent posts have been short and provide little more than featured code. This is a new approach for me. What do you think? Should I continue to pepper in these quick code snippet posts with little commentary?

Undo Functionality with a Limited Stack

Ben Griswold — Tue, 08 Jan 2008 02:00:32 +0000

After hours of discussions and documentation, we had a good understanding of the functional requirements. The ask was for a very complex, intelligent and “AJAXy” web application which would give financial advisors the ability to rebalance their clients’ portfolios based on a specified investment objective. Everyone was excited (especially me) until the final requirement was issued: “We would like the ability to undo actions.”

The request was reasonable. If I were an advisor I would wish for this feature as well, but this was a web application with literally dozens of ways to extend, manipulate and delete data. I had concerns but I agree to evaluate and potentially prototype. Before the meeting closed I was able to set the expectation that we would most likely need to limit the number of undos — after all we weren’t dealing with a web application with unlimited resources.

As it turned out, the implementation worked itself out nicely. Rather than “logging” each action, I opted to store the state of the data AFTER each action. For example, instead of being concerned about how a security was added to the client’s portfolio, I started caring only about the resulting new data item. As form changes were made, I pushed a copy of the new state onto a “LimitedStack.” When the undo action was triggered, I would then pop the previous state off the stack and update the form accordingly. Finally, as the stack approach the maximum number of undos, the item in the first position would be removed in order to make room for the new item being push into the last position.

At the moment, we are allowing for up to 6 undos. Each undo is being managed within the LimitedStack in Session State. I am concerned that we are effectively using ~6 times more memory to accommodate this requirement, but I’m hopeful that performance testing will ease my worries.

I’ve include the LimitedStack logic below. You will see it is using the LinkedList as its base.

I also found the copying of the state (which was a collections of nested objec references) to be an interesting problem which needed solving. I hope to comment about deep copying soon.

[Serializable()]
public class LimitedStack : LinkedList
{
    private int _maxItems;

    public int MaxItems
    {
        get { return _maxItems; }
        set
        {
            while (this.Count > value)
            {
                this.RemoveFirst();
            }
            _maxItems = value;
        }
    }

    public LimitedStack(int num)
    {
        _maxItems = num;
    }

    public T Peek()
    {
        return this.Last.Value;
    }

    public T Pop()
    {
        LinkedListNode node = this.Last;
        this.RemoveLast();
        return node.Value;
    }

    public void Push(T value)
    {
        LinkedListNode node = new LinkedListNode(value);
        this.AddLast(node);

        if (this.Count > _maxItems)
        {
            this.RemoveFirst();
        }
    }
}

What’s the Best Way to Manage a Database Queue?

Ben Griswold — Thu, 21 Jun 2007 03:09:17 +0000

This question circulates through the office about once a year. “Um, I have Windows service which processes requests which are queued in a database table. Everything is working great, but I would like to add a second instance of the service and I need to know the best way to ensure the services don’t step on each other. In other words, how do I mark each row as it is being processed so it won’t be picked up again?”

Here are the ingredients in my current ideal solution:

The table must include the following columns: a Unique Identifier such as RequestID, Status, LockedBy, and LockedTime. I also like to include RequestedTime and CompletionTime columns as I’ve found that capturing these values help when/if system stats are required.
The key is to lock the current request at the time of processing. To do so, you should use a transaction and an update lock.
I think it is important to pull requests off the queue in an intelligent order. FIFO is the best bet under most circumstances. In this case, the RequestedTime column becomes imperative (unless your RequestID is an auto-incrementing identity column and you are comfortable ordering on it.)
Finally, I like to make sure no request is left behind. Let’s say Service A locks a request for processing and then the application server crashes. I want the lock to eventually expire so Service B can pick up the row and save the day.

Assuming new requests are added to the queue as ‘Pending’ , one may use a routine similar to the one below to safely pull the next request off the queue:

create procedure [GetNextItemInQueue]
(
    @LockedBy varchar(75)
)
as 

set nocount on 

declare
    @Error                     int,
    @ExitCode                  int,
    @RowCount                  int,
    @PendingStatus               int,
    @MinutesBeforeBreakLock       int,
    @RequestId                   int

select
    @Error                      = 0,
    @ExitCode                   = 0,
    @RowCount                   = 0,
    @PendingStatus                = 1,
    @MinutesBeforeBreakLock        = 30 

begin tran ProcessQueue 

select top 1 @RequestId = RequestId
from Queue with (updlock)
where Status = @PendingStatus
and (LockedTime IS NULL OR
DateDiff(mi, LockedTime, GetDate()) >= @MinutesBeforeBreakLock)
order by RequestedTime Asc 

select @RowCount = @@RowCount, @Error = @@Error 

if (@RowCount = 0)
    goto ExitProc 

if (@Error <> 0)
    goto ErrorHandler 

update Queue
set    LockedBy = @LockedBy,
    LockedTime = GetDate()
where RequestId = @RequestId 

select @Error = @@Error
if (@Error <> 0)
    goto ErrorHandler 

select @RequestId as RequestId 

select @Error = @@Error
if (@Error <> 0)
    goto ErrorHandler 

goto ExitProc 

ErrorHandler:
    raiserror   (@Error, 16, 1)
    if @@trancount > 0
        rollback tran ProcessQueue
    select      @ExitCode =  -100 

ExitProc:
    commit tran ProcessQueue
    return      (@ExitCode)

Once the request is processed, a database call will be made to update the row’s Status to ‘Complete’ and CompletionTime.

Note, you may choose to change the status of each row from ‘Pending’ to ‘Processing’ when you do the initial lock. This is perfectly fine, but I’ve found that is unnecessary as the Processing status can be determined based on the value of other columns.

Again, that’s my current preferred implementation. Perhaps there are better solutions out there?

DataView.RowFilter Top Rows

Ben Griswold — Wed, 07 Feb 2007 21:25:35 +0000

Out of the box, you can do a lot with the DataView.RowFilter property, but you can’t make use of the top clause. However, if the view contains a column with unique values, you can obtain the same results by setting the Sort property and then generating a RowFilter which uses the in condition.

Here’s a sample:

public static DataView GetLatestComments(int numComments) { DataView Comments = new DataView(GetComments()); Comments.Sort = “DateCreated Desc“; string filter = string.Empty; string delimiter = string.Empty; numComments = Math.Min(numComments, Comments.Count); for (int i = 0; i < numComments; i++) { filter += delimiter + Comments[i]["Id"].ToString(); delimiter = “,“; } if (filter.Length > 0) { Comments.RowFilter = “Id in (“ + filter + “)“; } return Comments; }

Note how the delimited string is built. Phil Haack provided an interesting tip on concatenating a delimited string last year. Undoubtedly, we’ve all built delimited strings using our preferred method. If you sift through the post comments, you will see what I mean. Anyhow, I took a liking to the method Joe Cheng uses when he says he’s “feeling lazy and performance is not critical (which is the vast majority of the time).”

C# RoundToInterval()

Ben Griswold — Tue, 23 Jan 2007 01:28:58 +0000

Disclaimer: If I were a betting man, I would bet there’s some code which does the following kicking around a forum, blog or two already. Simply, I wasn’t lucky enough to find it. Hence, the IF in “if I were a betting man.”

I ran into a case today where I wanted to reduce unused space in a generated chart. I figured I could tighten up the chart if the minimum and maximum Y values were slightly beyond the min and max data point values. For example, if the largest value in my dataset is 14, I would make the maximum value, and the corresponding Y axis label, 16.

This fixed the real estate issue, but I didn’t like the my labels were now somewhat random and no longer looked clean. For example, 14.64 + 2 = ugly. To get around this, I opted to pad the values to the nearest interval of 5 and helps with perceived consistency.

Original Chart

RoundToInterval() Function

Note the IntervalRounding enum below. I consider it similar to Math.Round’s MidpointRounding enumeration where you can use MidPointRounding.ToEven to round a positive value to the nearest even number and MidPointRounding.AwayFromZero to round a value to the nearest number away from zero.

// Sample call: Rounds 17 to 20. decimal d = RoundToInterval(17M, 5M, IntervalRounding.Up); private static decimal RoundToInterval(decimal value, decimal interval, IntervalRounding rounding) { // Guard against the divide by zero exception if (interval == 0) return decimal.MinValue; // For example, round 18 to the nearest interval of 5 // Quotient = 3.6, Remainder = 0.6, Whole = 3 decimal quotient = decimal.Divide(value, interval); decimal remainder = decimal.Subtract(quotient, decimal.Floor(quotient)); decimal whole = decimal.Subtract(quotient, remainder); // Rounding to the nearest interval and remainder // is over half way to the next interval value if (rounding == IntervalRounding.Nearest && remainder >= .5M || // Or we force rounding to the next highest interval // and we have a remainder. In otherwords, our value // isn’t on an interval already rounding == IntervalRounding.Up && remainder > 0M) { return interval * (whole + 1); } else { return interval * whole; } } public enum IntervalRounding { Nearest = 0, Up = 1, Down = 2 }

Final Chart:

The chart is now using more available space and the Y axis labels are rounded to the provided interval.

Sorry for the blurry image. If you really squint you can read it. Maybe…

Secure PDF Display – A Second Chance

Ben Griswold — Mon, 13 Nov 2006 09:36:30 +0000

Recently, we had the opportunity to do some clean up work on a legacy web app. At the top of our list was to refactor PDF report rendering to the browser. The typical application use case was as follows:

User enters data.
User submits data.
User requests PDF report.
Application queues report.
Application processes report.
Application stores the report on the fileshare.
Application notifies user that report is ready.
User requests report.

There’s nothing too tricky here, yet we still managed to really botch it up since there were no less than three security issues associated with the process. First, we saved the PDF using an auto-incremented identifier for a filename. For example, the 123rd file would be named 123.pdf. Second, the PDFs were requested directly. In the case of a request for the 123rd report, https://www.site.com/reports/123.pdf would be displayed in the address bar. Finally, we didn’t have any authorization in place so any user could access any report if they were nosy enough and smart enough (and you didn’t have to be too smart) to crack the code.

We remedied the issue by first encrypting the querystring parameters. ID 123, in the example above, was being passed around all over the place and we put an end to it. We also put a layer of abstraction between the PDF request and the PDF display. This included a single ASPX page and a FileHandler class. The ASPX validated that the requestor had rights to view the report and then used the FileHandler class to check for the PDF’s existence and return a binary stream of the URL. This binary stream, in turn, was written out by the ASPX page for the user.

Here’s a block of the code from the ASPX page…

   1:  bool fileFound = FileHandler.FileExists(url);

2:

   3:  if (fileFound)

   4:  {

   5:      Response.Clear();

   6:      Response.ContentType = "application/pdf";

   7:      Response.AddHeader("Content-Disposition",

"inline;filename=report.pdf");

   8:      Response.BinaryWrite(

FileHandler.GetBinaryFileStream(url));

   9:  }

As for the FileHandler class, this code worked great, but still have a look at the bold green comment in the FileExists() function above. This one threw us for a loop when testing. As you can see, the function leverages the HttpWebRequest and HttpWebResponse objects to evaluate if a page URL exists. Here’s the gotcha. If 123.pdf didn’t exist, for example, and IIS gracefully handled this by redirecting to a custom 404 error page, the webrequest would be created for the existing 404 error page and it would provide a response. In this case, the FileExists() would return true even though 123.pdf doesn’t exist! Basically, custom error handling of PDF files had to be turned off in order for the FileExists() function to operate correctly.

Here’s the majority of the FileHandler class. And, man, were we lucky to get a second change to get it in place.

   1:  ///

   2:  /// The class checks for the existence of files

   3:  /// and streams them back to the caller

   4:  ///

   5:  public class FileHandler

   6:  {

   7:      ///

   8:      /// Validates the existence of a file/page by URL

   9:      ///

  10:      /// File or page by URL

  11:      /// True if exists else false

  12:      public static bool FileExists(string url)

  13:      {

  14:          bool pageExists = true;

15:

  16:          try

  17:          {

  18:              // Beware - if the site gracefully handles

the missing page through a redirection of a generic 404 error

page, the page is still considered to be found.

20:

  21:              // Request the page or PDF

  22:              System.Net.HttpWebRequest myHttpWebRequest

=(System.Net.HttpWebRequest)System.Net.WebRequest.Create(url);

23:

  24:              // Get the associated response for the

above request.

  25:              System.Net.HttpWebResponse myHttpWebResponse

= (System.Net.HttpWebResponse)myHttpWebRequest.GetResponse();

26:

  27:              if (myHttpWebResponse.StatusCode !=

System.Net.HttpStatusCode.OK)

  28:              {

  29:                  pageExists = false;

  30:              }

31:

  32:              myHttpWebResponse.Close();

  33:          }

  34:          catch (System.Net.WebException e)

  35:          {

  36:              if (e.Status ==

System.Net.WebExceptionStatus.ProtocolError)

  37:              {

  39:                  pageExists = false;

  40:              }

  41:          }

42:

  43:          return pageExists;

  44:      }

47:

  48:      ///

  49:      /// Streams binary representation of the web

page / file

  50:      ///

  51:      /// File or page by URL

  52:      /// Page binary stream

  53:      public static byte[] GetBinaryFileStream(

string url)

  54:      {

  55:          //string result = string.Empty;

  56:          byte[] data = null;

57:

  58:          try

  59:          {

  60:              if (FileExists(url))

  61:              {

  62:                  // Request the page or PDF

  63:                  System.Net.HttpWebRequest

myHttpWebRequest = (System.Net.HttpWebRequest)

System.Net.WebRequest.Create(url);

64:

  65:                  // Get the associated response for

the above request.

  66:                  System.Net.HttpWebResponse

myHttpWebResponse = (System.Net.HttpWebResponse)

myHttpWebRequest.GetResponse();

67:

  68:                  // Fill the binary reader

  69:                  System.IO.BinaryReader oStream = new

System.IO.BinaryReader(myHttpWebResponse.GetResponseStream(),

System.Text.Encoding.ASCII);

70:

  71:                  // Read the byte array. hack below?

  72:                  data = oStream.ReadBytes(100000000);

73:

  74:                  oStream.Close();

75:

  76:                  myHttpWebResponse.Close();

  77:              }

  78:          }

  79:          catch

  80:          {

  81:              throw;

  82:          }

83:

  84:          return data;

  85:      }

  86:  }