http://www.imtraum.com

There are a lot of samples that illustrate how to use Skip() and Take() to locate a page of data in a collection, however most examples leverage inline code.  While I appreciate the simplicity of demonstrating code in this manner, I think it promotes bad programming practices.  Rather than find a concept and integrate it intelligently into their application, most developers will plagerize the sample and move on their merry way without a thought of how the code “should” be integrated.

A method that I use (but by no means the only one) to integrate LINQ pagination into your application is to use an extension method.  This is an elegant approach because it encapsulates the pagination logic in a method that extends the functionality of IEnumerable<T>, and exposes paging functionality to all IEnumerable<T> collections in your application. 

The extension method: 

public static IEnumerable<T> GetPage<T>(this IEnumerable<T> source, int page, int recordsPerPage, out double totalPages)
{
    if (recordsPerPage <= 0)
    {
        throw new ArgumentOutOfRangeException("recordsPerPage", recordsPerPage, string.Format("recordsPerPage must have a value greater than zero.  The value you provided was {0}", recordsPerPage));
    }
    // get the first record ordinal position
    int skip = (page - 1) * recordsPerPage;

    // get the records per page
    var totalRecords = source.Count();

    // get the total number of pages
    var tp = totalRecords / (double)recordsPerPage;
    totalPages = Math.Ceiling(tp);

    return source.Skip<T>(skip).Take<T>(recordsPerPage);
}

Now, if you have a collection, perhaps something like… 

List<string> names = new List<string>();
names.Add("josh");
names.Add("penelope");
names.Add("linda");
names.Add("lauren");
names.Add("amy");
names.Add("cullen");
names.Add("kevin");
names.Add("john");

You can easily query the collection for a page of data like so…

double totalPages;
var pageOfNames = names.GetPage(1, 3, out totalPages);

The extension method extended the functionality of the List<T> (names) with a method that will get a specific page of data from the collection.  While the LINQ query itself is simple, this is far more reusable than having paging code all over your app.

Enjoy!

Let’s start with some content that we want to fade in and out.  In this case we’ll make a simple widget that displays a series of rotating banners to your site visitors.

First, we’ll create two container div elements to hold our banners.

<div id="outerContainer" style="background:#F00;height:175px;width:215px;">
    <div id="bannerContainer" style="position:relative;"></div>
</div>

You’ll notice that I’ve set the bannerContainer position to “relative” and provided a fixed size (height and width) to the outerContainer div.  Both will be very important later on.

Next, lets add the content that we want to fade in and out.  In this case, div’s that will hold our banners.

<div id="outerContainer" style="background: #F00;height:175px;width:215px;">
    <div id="bannerContainer" style="position:relative;">
        <div id="banner1" style="display:none;">
            <p>Hey, click here and buy our stuff!</p>
        </div>
        <div id="banner2" style="display:none;">
            <p>Clicky Clicky!</p>
        </div>
        <div id="banner3" style="display:none;">
            <p>Clicking here is good for you!</p>
        </div>
    </div>
</div>

Here I’ve set the banner div style display property to “none” to give a starting point where all the banners are hidden; we’ll dynamically pick the first banner to display with a bit of jQuery code.

Finally, we’re going to add the thing that will make all of this work.  I call it, “the hat”.

<div id="outerContainer" style="background: #F00;height:175px;width:215px;">
    <div id="bannerContainer" style="position:relative;">
        <div id="banner1" style="display:none;">
            <p>Hey, click here and buy our stuff!</p>
        </div>
        <div id="banner2" style="display:none;">
            <p>Clicky Clicky!</p>
        </div>
        <div id="banner3" style="display:none;">
            <p>Clicking here is good for you!</p>
        </div>
        <div id="bannerHat" style="position:absolute;background:#00F;top:0;left:0;height:175px;width:215px;display:none;"></div>
    </div>
</div>

bannerHat is a child of bannerContainer who’s style is set to position: absolute, top: 0 and left: 0, and display: none.  Additionally the bannerHat has the same display style (size, background, etc) as outerContainer.  This setup allows the bannerHat to be used to fade the banners without encountering the IE text fading issues.

The JavaScript that makes this work is very straight forward, but is a bit “backward” compared to the process of fading an item without the hat method.  The process looks like this (pseudo code):

1. (First time only)  jQuery.Show() one of the banners, it doesn’t matter which one.
2. After a period of time jQuery.fadeIn() the bannerHat div.  This will hide the banner with a nice fading out effect.
3. jQuery.Hide() the currently “visible” but hidden div.
4. jQuery.Show() one of the other banners.
5. jQuery.fadeOut() the bannerHat div.  This will show the banner with a nice fading in effect.
6. Wash, rinse, repeat.

So, let’s look at the JavaScript that will give us a random, rotating banner widget.

$(document).ready(function(){
 var options = {
  startIndex: 0,
  fadeInDuration: 1000,
  fadeOutDuration: 1000,
  rotationInterval: 10000,
  startDelay: 0
 };

 var rotator = function(containerSelector, hatSelector, options){
  var children = $(containerSelector).children();
  var startIndex = options.startIndex;
  var totalItems = children.length - 1; // this is so that we exclude the hat (the -1 part)
  
  $(children[startIndex]).show();
   setTimeout(function(){
    setInterval(function(){
     $(hatSelector).fadeIn(options.fadeOutDuration, function(){
      $(children[startIndex]).hide(function(){
       // determine the actual start index by adding one, then taking the modulus
       // this will give us the correct start index regardless of the number
       // of items we have to work with.
       startIndex = (startIndex + 1) % totalItems;
       $(children[startIndex]).show(function(){
        $(hatSelector).fadeOut(options.fadeInDuration);
       });
      });
     });
    }, options.rotationInterval);
   }, options.startDelay);
  };
  
  // randomly pick a start index and then initiate the rotation
  options.startIndex = Math.floor(Math.random()*3);
  rotator('#bannerContainer', '#bannerHat', options);}
 );
});

The JavaScript is pretty self-explanatory and shows how to use the hat to fade the banners in and out without directly fading the banners themselves.  This circumvents the issue with cleartype fonts when fading text in IE, works great in all the major browsers, and should be easy to adapt to any situation where you need to fade textual elements with JavaScript.

So now there shouldn’t be any excuses for terrible fading in IE (yeah, I’m lookin at you Facebook…).

My Alienware M15x Configuration

I’m not a believer in cutting edge hardware, so I usually spec my machines with the highest end componentry at the point where the price starts to dramatically increase, but isn’t out of hand.  I find that you get the best bang for your buck when buying your hardware with this in mind.  I could have spec’d the machine with the highest end stuff available, and it would have cost around $3600 without any extended warranty or accidental coverage.  Instead my laptop came in at $2100.00 for the hardware configuration, $2600.00 ish when you factor in the 3 year extended warranty with accidental damage coverage.  Since I am somehow prone to having other people wreck my stuff, I figure I can’t go wrong with the accidental coverage…

The processor is a good example of getting good bang for the buck.  This was only a $100.00 upgrade from the stock processor, while the next one up cost $400.00 and only gave you a nominal core speed increase.  Considering the applications that I run are not CPU bound, this was a choice that saved quite a bit of money and still gave me a fast quad core processor that can be upgraded at a later date if I find the machine lacking in horsepower.

I decided on 4GB of memory rather than my initial instinct to max the box out at 8GB.  While more RAM would be great, I generally don’t find myself running out of memory.  When I do, the machine will take 8GB and upgrading should be fairly inexpensive in a year or two.  Going with 4GB saved me $300.00 over the 8GB upgrade.

Finally, I elected to stay with the stock 6 cell battery rather than upgrade to the 9 cell version.  After reading reviews I found that the 9 cell only gave about 90 minutes of battery life; a moderate 30 minute increase over the stock 6 cell battery.  For a $100.00 upgrade, this just didn’t seem like that great of a deal considering this laptop will rarely find itself in a starbucks or any other scenario where I don’t have access to power.  I’ll plug the box in when in my living room; it will be faster that way anyway.

I’ll do a more detailed write up after I get this thing set up and get some time to poke around.  I can’t wait!

So, with mixed feelings I killed the project.  It simply cost too much money to maintain the website and merchant account for a product that only sold a handful of licenses over the 18-24 months.

I’m left wondering what to do with the project.  There are a few options:

1. Create a codeplex project
2. Host the source code myself
3. Release the addin as freeware (no source code)
4. Release the addin as freeware with sponsorship (uhg, gross right?) (no source code)
5. Leave the project inactive and move on to other exciting technologies

I’m wondering if I really want to spend more effort supporting the project as a whole, though with so much time invested, its hard to walk away from it.  Part of me would like to see more people use .netSavant, if only to justify the time I spent creating it.  I’d also like the challenge of updating some of the methodology used to generate the source code, and possibly provide some extensibility points to enhance the analysis features that it supports.

Perhaps some day .netSavant will be resurrected in a better form.  Until that time, thanks for your interest and support.

Joshua

Cracking Passwords in the Cloud

It’s interesting to see how easy it  has becomes to brute force passwords using distributed computing. While brute force attacking passwords for the average person is still time-prohibitive, even with a cloud, the ability to reduce password cracking times from years to weeks is impressive.  Cracking performance will continue to increase as distributed computing becomes cheaper, faster and more widely adopted.

Take a look at the article and think of how this could affect your data:  Cracking Passwords in the Cloud

If you haven’t started to really focus on application data security, perhaps you should…

• Created Tools Options Page options to select which methods will be implemented for statements (stored procedures and inline sql).  This allows greater customization of the code that .netSavant generates by excluding methods that you never use.  Personally I never use DataTable or DataSet objects, so I have .netSavant configured to exclude these methods when generating my code.
• Simpler Unit testing support is achieved by not including code that you have no intention of using.  See the point above.
• Updated the VB.NET and C# code generation framework to format the generated code a bit more cleanly.  Who likes messy code right?
• Updated VB.NET generated code to use using statements rather than Try blocks for objects that implement the IDisposable interface.
• Updated the database connection form to default to the SQL Server provider rather than forcing you to select it each time.
• Numerous bug fixes.

I highly recommend upgrading to this version, visiting the Tools > Options page to set your preferences, and regenerating any legacy .netSavant code.

Enjoy!!!

But how do you find out what exceptions are being thrown by users who are not you?  Over the years I’ve created many versions of the same type of code to handle these situations, so last night I created a project on codeplex that I’m calling sigh.net.  Essentially, sigh.net is a provider based unhandled exception handler for ASP.NET applications.  You can download the source at http://www.codeplex.com/sigh.

It’s extremely simple to use and doesn’t require you to change or add any code to your application.  I currently have an email provider created and am in the process of creating a SQL database provider.

Enjoy!

Click Here to read the article

To date I’ve only created and published a single tutorial for .netSavant.  I’ve several more planned that will hopefully be a bit more polished as I become more comfortable talking, effectively, to no one.

http://www.dotnetsavant.com/Overview/Tutorials.aspx

Enjoy!

Download the C# file (in txt format)

Enjoy!