Iteratively Perfecting: 2011

Wednesday, November 30, 2011

LINQ to SQL HA HA HA

When contemplating the motivation for doing away with the impedance created between an Object Oriented app and a Relational Database, and thus ultimately LINQ and Entity Framework, I would struggle to feel convinced (I'm equally comfortable writing T-SQL in Management Studio as I am writing VB and C# in Visual Studio).

If anything stood out in my mind as inconvenient, it would certainly be the tedious and redundant variable/field names when writing queries. I was always adept at solving such problems with a good text editor at my side that could use vertical highlighting and Regular Expressions (such as Textpad), so this wasn't that big a deal. But nonetheless, I found (and am still finding) the 2008 SQL Server Management Studio's Intellisense capabilities (FINALLY!!) to be amazingly helpful. So helpful that, if I did have any desires to lower the impedance between a OOP architected app and an RDBMS, the 2008 tool would have satisfied it.

So, this is the irony. The tool's improvements were released the SAME TIME as the company (Microsoft) was pushing LINQ to SQL and Entity Framework.

And this seems a bit absurd to me.

But wait, there's more...“LINQ to SQL is dead!”

Monday, September 26, 2011

1.x DataGrid, 2.0 GridView, Declarative Syntax in HTML portion...

"In Microsoft ASP.NET 1.x, one of the most commonly used ASP.NET Web controls is the DataGrid. The DataGrid control makes displaying data on an ASP.NET page a breeze: simply drag and drop the DataGrid onto your ASP.NET page, specify the columns and formatting, and write just a few lines of source code to retrieve and bind the data to the DataGrid. With a bit more effort and code, you could enable the end user to page, sort, and even edit the data within the DataGrid.

While the DataGrid was a huge improvement over pre-ASP.NET techniques for displaying data, it still suffered some limitations. For starters, binding any data to a DataGrid required some code writing, and often repetitive code at that. Furthermore, utilizing any of the DataGrid's more advanced features—handling deletes, allowing for editing of the underlying data, providing pagination, or sorting support—required additional code and time. Granted, the code for many of these additions was not terribly complex or lengthy, but any time code is written the possibility of new bugs, typos, or errors is introduced.

ASP.NET 2.0 fixes the problems of the DataGrid through a set of data source controls designed to encapsulate data that can be bound to data Web controls, and a replacement for the DataGrid—the GridView control. To access data in ASP.NET 1.x, developers had to write code; with the data source controls, however, data can be accessed through declarative syntax in the HTML portion of the ASP.NET Web page. Like other ASP.NET controls, the data source controls can be added to a page by simply dragging and dropping them from the Microsoft Visual Studio Toolbox onto the ASP.NET page Design view. Additionally, the specific data to retrieve can be specified entirely through the Design view. Once a data source control has been configured, it can be bound to a data Web control, such as the GridView, by setting the data Web control's DataSourceID property to the ID of the data source control. That's all there is to it—no code necessary!"

http://msdn.microsoft.com/en-us/library/aa479340.aspx

Tuesday, September 20, 2011

Basic IFrame Use with JavaScript

Here is the simplest example:

<html>
<body>
<iframe id="smedly" src="http://www.google.com"></iframe>
<input type="button" onclick="dothis();" value="Yahoo">
<script>
function dothis(){
document.getElementById('smedly').setAttribute('src','http://www.yahoo.com');
}
</script>
</body>
</html>

Friday, August 5, 2011

jQuery toggleClass with Visibility

I'm not sure why jQuery uses the CSS property "display" to toggle hide and show, since "display" when set to "none" (which jQuery.hide() does) removes the space it takes up, and if you have elements adjacent, they're going to move around.

The workaround is to use toggleClass with a class you create which is used exclusively for setting "visibility" to "hidden" (instead of "visible"). When an element is "hidden", it is still there taking up space, keeping other elements properly aligned, it just is invisible.

The typical example of the use case is when you have a blank area that when hovered over displays some tool icons, or a delete X.

However, you might run into a confusing problem if you try this without giving the element to be toggled on and off the invisible class to begin with.
Ex.:



//style

.hidden{

     visibility: hidden;

}

//HTML

<span class='hidden del'>X</span>

......

//jQuery

$('.editbay').hover(function(){

    $(this).find('span').toggleClass('hidden');

});

Friday, July 29, 2011

Firebug musts

for(x in console)
{
console.log(console[x].name)
};

console.dir(console);

Thursday, April 7, 2011

Lambda Expressions and Delegates

"[T]he syntax for delegates is a little confusing and verbose. Lambda expressions offer a much more terse syntax for defining an anonymous method. " - Scott Mitchell

Following excerpt from http://www.codeguru.com/vb/gen/vb_general/ideincludingvisualstudionet/article.php/c15441/Slow-Chat-with-the-MS-Visual-Basic-Team.htm#page-2

Question: (Originally by techgnome)

As I understand it, Lambda Expressions were added to provide functionality for LINQ. My questions are as follows:

What the heck is it?
What would I use it for? Bonus points for explaining why I would and/or not use it in some circumstances. Or better, a situation in which I could use it, but shouldn't.
Could you provide an example of one? This is where I've had problems; most of the examples I've seen have been so esoteric, that I just don't get it.

MS Response: (funkyonex)

Hi technome,

I actually had trouble learning them as well and am very thankful that Visual Basic provides the common ones you use in LINQ queries as query expressions instead. So, I think I'll go for the "bonus points"...

Here's an example of a simple Lambda Expression, or as I like to call them, inline functions, that adds x to itself:


Dim myFunc = Function(x) x + x

To call this, we could write:


Console.Writeline(myFunc(2))

Which results in: 4

Extension Methods are another new feature and allow you to create methods that extend any type. For instance, you could create your own Print method on the string class. The LINQ framework relies heavily on Lambda expressions as well as Extension Methods. In fact, the LINQ syntax we see in Visual Basic is really just abstracting away Extension Methods and Lambda Expressions for us in most cases. For instance, the Sum extension method accepts a Lambda Expression as one of its parameters. Say we want to sum only even numbers in an array. We can do this in one line of code using a Lambda Expression:


Dim x As Integer() = {1, 2, 3, 4, 5, 6}
Dim sumofEvens = x.Sum(Function(y) If(y Mod 2 = 0, y, 0))

Lambda functions start to get really useful (and necessary) when we start writing LINQ queries. Say we want to Sum all of the products in our products collection by multiplying the UnitPrice by the UnitsInStock. We could write this:


Dim total = (From Product In db.Products) _
   .Sum(Function(p As Product) p.UnitPrice * p.UnitsInStock)

But why? (I think this is my bonus point) In Visual Basic, we don't have to write Lambda Expressions to do aggregate operations like this. (See here: http://msdn2.microsoft.com/en-us/library/bb546138(VS.90).aspx.) We can instead write this using Visual Basic's Query Expressions:


Dim total = Aggregate Product In db.Products _
   Into Sum(Product.UnitPrice * Product.UnitsInStock)

I love it! Much easier to figure out what's going on, IMHO. I hope that helps clear it up.

Static Pages