C#

Developer: Utilizing .NET Generics to write better code by Shawn Weisfeld @ UT Dallas .NET UG on 02/27/2010

Shawn Weisfeld — Thu, 25 Feb 2010 01:45:54 GMT

This Saturday (2/27) I will be giving my .NET Generics talk for the UT Dallas .NET UG in Richardson TX. If you are in the area please check it out (http://www.usergroupsupportservices.com/UGEventView.ugss?EventID=9160). If you cannot make it but are interested in seeing the talk, you can watch it online.

Abstract:
Generics let you tailor a method, class, structure, or interface to the precise data type it acts upon. In this session we will discuss what capabilities Generics provide to you the developer and how to use them in collections, and with delegates. We will also talk about creating your own generic classes and methods.

Download
PowerPoint & Demos

Bio:
Shawn Weisfeld (shawn@shawnweisfeld.com) is a Staff Developer at a fortune 100 company, currently located at Dallas TX facility. There he specializes in intranet & smart client development for internal line of business applications. Besides his day job Shawn also is an Adjunct Professor at The Florida Institute of Technology (http://www.fit.edu). He also does freelance software development work for local small businesses and training. In his free time he volunteers with INETA NorAm (http://www.ineta.org) and is a member of the Board of Directors and Mentor for North Texas. Shawn started his career at his family business in Port St. Lucie FL while working on his undergraduate degree in Business Administration at the University of Central Florida and after a year off Shawn moved back to Orlando to pursue a Masters degree in Management Information Systems at The University of Central Florida and has since earned a second Masters degree in Computer Information Systems from Florida Institute of Technology. Shawn was awarded the Microsoft C# Most Valuable Professional award for 2007 - 2010. Shawn is an avid technology presenter and since July of 2005 Shawn has presented at many user group events, and even got to speak at the launch of Visual Studio. Shawn has served as the President of the Orlando .NET UG (http://www.onetug.org) from 2006 – 2008, and started the Developer Round Table UG (http://www.developerroundtable.com) in 2009. Shawn regularly attends, and records for INETA LIVE (http://live.ineta.org), many of the local user groups in the D/FW metroplex, including; D/FW Connected Systems UG, Dallas .NET UG, Dallas ASP.NET UG, Dallas C# Programming Sig, Dallas VSTS UG, North Dallas .NET UG, North Texas PC UG, UT Dallas .NET UG. So be sure to say hello if you see him.

Shawn @ Dallas Dev Cares 2009/12/11

Shawn Weisfeld — Sat, 12 Dec 2009 16:10:00 GMT

Thanks to all that attended my 3 talks at the Dallas Dev Cares UG yesterday and thanks Ken Byrd from TekFocus for hosting the meeting. As promised here is the download of the PowerPoint and code bits. I also included links to recordings of 2 of the 3 talks.

Download Presentations Here

Recording of ASP.NET Dynamic Data:

Recording of Developer of <T> Generics talk:

Dallas DevCares – Dec 11 2009: C# Generics, ASP.NET Dynamic Data & VS.NET Tips and Tricks

Shawn Weisfeld — Tue, 10 Nov 2009 12:43:44 GMT

By popular request on Dec 11 I will be giving 2 of my most popular talks on C# Generics and ASP.NET Dynamic Data. Then as a bonus just for the DevCares Community I will put together some of my favorite VS.NET Tips and Tricks. You can attend online or in person. Get all the details on there website at http://www.dallasdevcares.com/

Tulsa Tech Fest 2009

Shawn Weisfeld — Fri, 06 Nov 2009 15:37:36 GMT

Thanks to everyone that attended my .NET Generics Talk at the Tulsa Tech Fest today. You can download the code and PowerPoint here, and the recording will be posted to this blog and INETA Live shortly.

Developer<T>: Utilizing .NET Generics to write better code

Shawn Weisfeld

Generics let you tailor a method, class, structure, or interface to the precise data type it acts upon. In this session we will discuss what capabilities Generics provide to you the developer and how to use them in collections, and with delegates. We will also talk about creating your own generic classes and methods.

I wanted to thanks Scott Dorman author of the yet to be released Sams Teach Yourself C# 2010 in 24 Hours, for his help during the creation of this presentation.

Call a Multiple-Rowset stored procedure with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 21:45:23 GMT

Multiple-Rowset allows you to return more than one select from your stored procedure. For example in the stored procedure below you can see we have 2 select statements.

As we learned in my last 2 posts it is possible to use LINQ to SQL without the designer.

A simple select with LINQ to SQL and without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/a-simple-select-with-linq-to-sql-and-without-the-designer.aspx)
Call a stored procedure with LINQ to SQL and without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/call-a-stored-procedure-with-linq-to-sql-and-without-the-designer.aspx)

To utilize Multiple-Rowset we just need to tweak our function in our data context a little.

Here you can see that we added 2 result type attributes. These map to our result sets. Since our stored procedure returns 2 result sets of customers we tell LINQ to SQL to mach each to the customer object. However if your stored procedure returns different types you can of course do that. We also changed our result type to that of IMultipleResults. This will allow us to pick off each of the result sets when we call our method.

Here is the call to the method. You can see when we call “GetResult” the first time we get our first result set. Then when we call it a second time we get the second result set.

That is it.

Call a stored procedure with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 03:15:00 GMT

In my last post I talked about how to do a simple select with LINQ to SQL without the designer (http://drowningintechnicaldebt.com/blogs/shawnweisfeld/archive/2009/07/11/a-simple-select-with-linq-to-sql-and-without-the-designer.aspx). This is all well and good, but what if you need to use a stored procedure. Like this one. . . .

The first step is to add to our data context a method that maps to our stored procedure. You can see we start off with a Function attribute that tells LINQ to SQL what stored procedure to use. Additionally we decorate the parameters on our method with Parameter attributes that tell LINQ to SQL how to map the parameters. Then we just call our base classes ExecuteMethodCall passing along all the attributes (using the .NET reflection MethodInfo class), and our parameter.

Now we just need to use our new method.

Here we can see we get the same results as we did in my last post.

In my next post we will use Multiple-Rowset to return multiple result sets from my stored procedure.

A simple select with LINQ to SQL and without the designer

sweisfeld — Sun, 12 Jul 2009 02:57:42 GMT

Many folks poo-poo LINQ to SQL because they don’t like designers. On the other hand some developers, myself included, like knowing how things work behind the scenes, for those edge case moments when the designer cannot do something. The most common business case for this is if you want to LINQ to SQL-afy an existing suite of objects. Well using the designers is NOT a requirement of LINQ to SQL.

Lets say for example you had an existing customer table and customer business object:

Lets see if we can get LINQ to SQL to populate a list of customers from the database.

Ok first we need to make sure we have a valid connection string.

The next step is to create our DataContext. If you have used LINQ to SQL you will know that this guy does all the heavy lifting when it comes to getting data from and pushing data to the database.

Creating the DataContext is simple. Just create a new class and set its parent class to DataContext. (You will probably need to add a reference to System.Data.Linq.) Once you have the class created create a private static member called for the mapping source, and a constructor. The mapping source tells LINQ if it should look for attributes on the object, or in an xml configuration file for instructions on how to map the object model to the db model. This constructor will be chained to our base class passing up the mapping source and the connection string.

Since we selected an Attribute Mapping Source, lets go and decorate our customer class. using the attributes in the System.Data.Linq.Mapping namespace I tell LINQ to SQL what db table our object maps to and what columns each of the properties map to.

The next step is to add a helper method to our Data Context exposing the data so we can easily query it.

Now we can just write our LINQ query, just like normal.

That is it a simple LINQ to SQL query without the designer. Here are the results of the above query.

In my next post I will kick this up a notch by using a stored procedure to get these same results.

Extension Method to Resize an Image

sweisfeld — Sun, 28 Jun 2009 23:52:00 GMT

I wrote this for an INETA project that I have been working on, but thought it would be great to share with everyone. We had a need to take an image and change its size. Below is an implementation of a Resize Extension Method on the .NET Image object.

I borrowed some ideas from this post by Mark McDonnell (http://weblogs.asp.net/markmcdonnell/archive/2008/03/09/resize-image-before-uploading-to-server.aspx)

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Linq;

   4:  using System.Text;

   5:  using System.Drawing;

   6:  using System.Drawing.Drawing2D;

7:

   8:  namespace Demo

   9:  {

  10:      public enum ResizeMode

  11:      {

  12:          Width,

  13:          Height,

  14:          Bigger

  15:      }

16:

  17:      public static class ImageHelper

  18:      {

  19:          public static Image Resize(this Image source, int size, ResizeMode mode)

  20:          {

  21:              //Convert the source image into a bitmap so we can work with it

  22:              Bitmap originalBMP = new Bitmap(source);

  23:              Image result;

24:

  25:              // Calculate the new image dimensions

  26:              int origWidth = originalBMP.Width;

  27:              int origHeight = originalBMP.Height;

  28:              int newWidth = 0;

  29:              int newHeight = 0;

30:

  31:              //If the size mode is set to bigger then find the widest side

  32:              if (mode == ResizeMode.Bigger)

  33:              {

  34:                  if (origHeight > origWidth)

  35:                      mode = ResizeMode.Height;

  36:                  else

  37:                      mode = ResizeMode.Width;

  38:              }

39:

  40:              //keeping the aspect ratio constant, calculate the new size

  41:              if (mode == ResizeMode.Width)

  42:              {

  43:                  newWidth = size;

  44:                  newHeight = (int)(size / ((double)origWidth / (double)origHeight));

  45:              }

  46:              else

  47:              {

  48:                  newHeight = size;

  49:                  newWidth = (int)(size / ((double)origHeight / (double)origWidth));

  50:              }

51:

52:

  53:              // Create a new bitmap which will hold the previous resized bitmap

  54:              Bitmap newBMP = new Bitmap(originalBMP, newWidth, newHeight);

55:

  56:              // Create a graphic based on the new bitmap

  57:              using (Graphics oGraphics = Graphics.FromImage(newBMP))

  58:              {

  59:                  // Set the properties for the new graphic file

  60:                  oGraphics.SmoothingMode = SmoothingMode.AntiAlias;

  61:                  oGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

62:

  63:                  // Draw the new graphic based on the resized bitmap

  64:                  oGraphics.DrawImage(originalBMP, 0, 0, newWidth, newHeight);

65:

  66:                  // Save the new graphic file to the server

  67:                  result = newBMP.Clone() as Image;

68:

  69:                  // Once finished with the bitmap objects, we deallocate them.

  70:                  originalBMP.Dispose();

  71:                  newBMP.Dispose();

  72:                  oGraphics.Dispose();

  73:              }

74:

  75:              return result;

  76:          }

  77:      }

  78:  }

Using an extension method makes it really easy to use the new “resize” functionality:

   1:              Image img = Image.FromFile("img.jpg");

   2:              Image resized = img.Resize(100, ResizeMode.Bigger);

   3:              resized.Save("resized.jpg");

So we went from a source size of 2304x1728 and 782 KB

to 100x75 and 23.3 KB

Now you to can shrink the size of your memories. :)

Property Causing a Stack Dump

sweisfeld — Tue, 16 Jun 2009 05:26:50 GMT

Got a call today, someone was getting a stack dump every time they tried to assign a value to a property. Here is a screen print of the problem they were having. can you spot the problem?

If you said that the property is calling itself you get a gold star. What was happening is that every time we tried to set the Name property, it calls the Name property to set it, and that called the Name property, and that called the Name property, over and over again, till .NET stack dumped. We are missing a backing variable.

By backing the property with a private variable, it removes the infinite recursion. Since the variable itself is private nobody can see it, or can use it outside the class, they are forced to use the property, and all is right with the world again!

Austin Code Camp 2009

sweisfeld — Sat, 30 May 2009 17:32:19 GMT

Coming from Florida where I attended every code camp and spoke at every code camp except for one, well until I moved it is nice to be getting into the swing of things out here in Texas. Today I will be giving my ASP.NET Dynamic Data talk at the Austin Code Camp and I cannot wait. I will be repeating the presentation at the Dallas Tech Fest on June 19 if you cannot make it today.

Austin Code Camp: http://www.adnug.org/AustinCodeCamp09

Presentation Download

Dallas Tech Fest: http://dallastechfest.com/ (while the early bird discount is over, you can still use the discount code DOTNET to get $25 off admission)