The Code Slinger

Auto Generate History Table and Corresponding Trigger (SQL)

Pete — Fri, 11 Feb 2011 18:54:23 +0000

Extending the excellent work of this post by Bryan Massey, I’ve updated the script to replace the deprecated SysProperties table in lieu of the sys.extended_properties so that this procedure will operate in SQL 2008. Enjoy!

/************************************************************************************************************
Created By: Bryan Massey
Created On: 3/11/2007
Modified By: Peter Samwel
Modified On: 2/11/2011 — Updated SysProperties table refs (deprecated) to use the new (2008) extended_properties view.
Comments: Stored proc performs the following actions:
1) Queries system tables to retrieve table schema for @TableName parameter
2) Creates a History table (“History_” + @TableName) to mimic the original table, plus include
additional history columns.
3) If @CreateTrigger = ‘Y’ then it creates an Update/Delete trigger on the @TableName table,
which is used to populate the History table.
******************************************* MODIFICATIONS **************************************************
MM/DD/YYYY – Modified By – Description of Changes
************************************************************************************************************/
CREATE PROCEDURE [dbo].[History_Bat_AutoGenerateHistoryTableAndTrigger]
@TableName VARCHAR(200),
@CreateTrigger CHAR(1) = ‘Y’ — optional parameter; defaults to “Y”
AS

DECLARE @SQLTable VARCHAR(8000), @SQLTrigger VARCHAR(8000), @FieldList VARCHAR(6000), @FirstField VARCHAR(200)
DECLARE @TAB CHAR(1), @CRLF CHAR(1), @SQL VARCHAR(1000), @Date VARCHAR(12)

SET @TAB = CHAR(9)
SET @CRLF = CHAR(13) + CHAR(10)
SET @Date = CONVERT(VARCHAR(12), GETDATE(), 101)
SET @FieldList = ”
SET @SQLTable = ”

DECLARE @TableDescr VARCHAR(500), @FieldName VARCHAR(100), @DataType VARCHAR(50)
DECLARE @FieldLength VARCHAR(10), @Precision VARCHAR(10), @Scale VARCHAR(10), @FieldDescr VARCHAR(500), @AllowNulls VARCHAR(1)

DECLARE CurHistoryTable CURSOR FOR

– query system tables to get table schema
SELECT CONVERT(VARCHAR(500), SP2.value) AS TableDescription,
CONVERT(VARCHAR(100), SC.Name) AS FieldName, CONVERT(VARCHAR(50), ST.Name) AS DataType,
CONVERT(VARCHAR(10),SC.length) AS FieldLength, CONVERT(VARCHAR(10), SC.XPrec) AS FieldPrecision,
CONVERT(VARCHAR(10), SC.XScale) AS FieldScale,
CASE SC.IsNullable WHEN 1 THEN ‘Y’ ELSE ‘N’ END AS AllowNulls
FROM SysObjects SO
INNER JOIN SysColumns SC ON SO.ID = SC.ID
INNER JOIN SysTypes ST ON SC.xtype = ST.xtype
LEFT OUTER JOIN sys.extended_properties SP ON SC.ID = SP.major_id AND SC.ColID = SP.minor_id
LEFT OUTER JOIN sys.extended_properties SP2 ON SC.ID = SP2.major_id AND SP2.minor_id = 0
WHERE SO.xtype = ‘u’ AND SO.Name = @TableName
ORDER BY SO.[name], SC.ColOrder

OPEN CurHistoryTable

FETCH NEXT FROM CurHistoryTable INTO @TableDescr, @FieldName, @DataType,
@FieldLength, @Precision, @Scale, @AllowNulls

WHILE @@FETCH_STATUS = 0
BEGIN

– create list of table columns
IF LEN(@FieldList) = 0
BEGIN
SET @FieldList = @FieldName
SET @FirstField = @FieldName
END
ELSE
BEGIN
SET @FieldList = @FieldList + ‘, ‘ + @FieldName
END

IF LEN(@SQLTable) = 0
BEGIN
SET @SQLTable = ‘CREATE TABLE [DBO].[History_' + @TableName + '] (‘ + @CRLF
SET @SQLTable = @SQLTable + @TAB + ‘[History' + @FieldName + '] [INT] IDENTITY(1,1) NOT NULL,’ + @CRLF
END

SET @SQLTable = @SQLTable + @TAB + ‘[' + @FieldName + '] ‘ + ‘[' + @DataType + ']‘
IF UPPER(@DataType) IN (‘CHAR’, ‘VARCHAR’, ‘NCHAR’, ‘NVARCHAR’, ‘BINARY’)
BEGIN
SET @SQLTable = @SQLTable + ‘(‘ + @FieldLength + ‘)’
END
ELSE IF UPPER(@DataType) IN (‘DECIMAL’, ‘NUMERIC’)
BEGIN
SET @SQLTable = @SQLTable + ‘(‘ + @Precision + ‘, ‘ + @Scale + ‘)’
END

IF @AllowNulls = ‘Y’
BEGIN
SET @SQLTable = @SQLTable + ‘ NULL’
END
ELSE
BEGIN
SET @SQLTable = @SQLTable + ‘ NOT NULL’
END

SET @SQLTable = @SQLTable + ‘,’ + @CRLF

FETCH NEXT FROM CurHistoryTable INTO @TableDescr, @FieldName, @DataType,
@FieldLength, @Precision, @Scale, @AllowNulls
END

CLOSE CurHistoryTable
DEALLOCATE CurHistoryTable

– finish history table script with standard history columns
SET @SQLTable = @SQLTable + @TAB + ‘[HistoryCreatedOn] [DATETIME] NULL,’ + @CRLF
SET @SQLTable = @SQLTable + @TAB + ‘[HistoryCreatedByUserID] [SMALLINT] NULL,’ + @CRLF

SET @SQLTable = @SQLTable + @TAB + ‘[HistoryCreatedByUserName] [VARCHAR](30) NULL,’ + @CRLF
SET @SQLTable = @SQLTable + @TAB + ‘[HistoryAction] [CHAR](1) NOT NULL’ + @CRLF
SET @SQLTable = @SQLTable + ‘ )’

PRINT @SQLTable

– execute sql script to create history table
EXEC(@SQLTable)

IF @@ERROR <> 0
BEGIN
PRINT ‘******************** ERROR CREATING HISTORY TABLE FOR TABLE: ‘ + @TableName + ‘ **************************************’
RETURN -1
END

IF @CreateTrigger = ‘Y’
BEGIN
– create history trigger
SET @SQLTrigger = ‘/************************************************************************************************************’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘Created By: ‘ + SUSER_SNAME() + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘Created On: ‘ + @Date + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘Comments: Auto generated trigger’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘***********************************************************************************************/’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘CREATE TRIGGER [Trigger_' + @TableName + '_UpdateDelete] ON DBO.’ + @TableName + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘FOR UPDATE, DELETE’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘AS’ + @CRLF + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘DECLARE @Action CHAR(1)’ + @CRLF + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘IF EXISTS (SELECT ‘ + @FirstField + ‘ FROM Inserted)’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘BEGIN’ + @CRLF
SET @SQLTrigger = @SQLTrigger + @TAB + ‘SET @Action = ”U”’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘END’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘ELSE’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘BEGIN’ + @CRLF
SET @SQLTrigger = @SQLTrigger + @TAB + ‘SET @Action = ”D”’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘END’ + @CRLF + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘INSERT INTO History_’ + @TableName + @CRLF
SET @SQLTrigger = @SQLTrigger + @TAB + ‘(‘ + @FieldList + ‘, HistoryCreatedOn, HistoryCreatedByUserName, HistoryAction)’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘SELECT ‘ + @FieldList + ‘, GETDATE(), SUSER_SNAME(), @Action’ + @CRLF
SET @SQLTrigger = @SQLTrigger + ‘FROM DELETED’
–PRINT @SQLTrigger
– execute sql script to create update/delete trigger
EXEC(@SQLTrigger)

IF @@ERROR <> 0
BEGIN
PRINT ‘******************** ERROR CREATING HISTORY TRIGGER FOR TABLE: ‘ + @TableName + ‘ **************************************’
RETURN -1
END

END

Client Specific Metadata in your MVC Application

Pete — Mon, 31 Jan 2011 18:21:52 +0000

Recently I was working on a new requirement for one of our systems in which each different client may refer to the same data types differently. For example, ClientA might refer to roadways as a “Parkways” whereas ClientB and ClientC might refer to them as “Highways”. Changes like these obviously aren’t big enough to warrant separate Views for each screen in which data types like these are referenced or mentioned, however sometimes small things like that make a big difference to the client and makes the application feel more in line with their existing business processes.

So, in order to make it so that my application is still a single code-base that will work for all the various clients that might come along and their varying terminologies, here is what I came up with that I think integrates nicely into an existing MVC application and requires only slight modifications.

First off, here is my interface and concrete implementation of a dictionary wrapper that I will use to not only store the key/value pairs which represent the data types but which will be what my Views utilize as an appendage to their ViewModel instances.

    public interface IMeta
    {
        MetaDictionary Meta { get; set; }
    }
 
    public class MetaDictionary
    {
        private Dictionary<string, KeyValuePair<string,string>> dict;
        public MetaDictionary()
        {
            dict = new Dictionary<string, KeyValuePair<string, string>>();
        }
 
        public void Add(string key, KeyValuePair<string,string> value)
        {
            if (!dict.ContainsKey(key))
                dict.Add(key, value);
            else
                dict[key] = value;
        }
        public void Remove(string key)
        {
            if (dict.ContainsKey(key))
                dict.Remove(key);
        }
 
        public string GetValue(string key)
        {
            if(dict.ContainsKey(key))
                return dict[key].Key;
            else
                return "";
        }
        public string GetValueAbbrev(string key)
        {
            if(dict.ContainsKey(key))
                return dict[key].Value;
            else
                return "";
        }
    }

Next, I need to write an action filter that will fetch the appropriate key/value pairs relevant to the currently logged in user and which client they belong to. Please note that this is where your logic goes to determine A) where to retrieve your key/value pairs to begin with (DB, XML, config file, etc) and B) what differentiating factor(s) you might have which would determine how your application knows each client. In my situation, I currently have a variable which would store the ClientID in a pre-existing injected Session wrapper. Also note, I’m using StructureMap as my DI container.

    public class ClientMetaAttribute : ActionFilterAttribute, IActionFilter
    {
        private readonly IControllerDependency Services;
        public ClientMetaAttribute():this(ObjectFactory.GetInstance<IControllerDependency>())
        {
        }
        public ClientMetaAttribute(IControllerDependency service)
        {
            Services = service;
        }
        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            //Lookup all appropriate attributes.
            int? clientid = Services.SessionHandler.ClientID;
            var metadict = new MetaDictionary();
            //FILL YOUR META dictionary here!!
  
           ((IMeta)((ViewResultBase)filterContext.Result).ViewData.Model).Meta = metadict;
            base.OnResultExecuting(filterContext);
        }
 
        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            base.OnResultExecuted(filterContext);
        }

Now, once I’ve implemented IMeta in the ViewModel used for my action method:

    public class ClientViewModel: IMeta
    {
        public MetaDictionary Meta { get; set; }
        //Rest of model class definition…
    }

Then I simply need to update any hardcoded references within View(s) which use this ViewModel such as:

<%: Model.Meta.GetValue("roadname") %> (<%: Model.Meta.GetValueAbbrev("roadname") %>)

Which for ClientA will give me

Parkway (PKWY)

and for for ClientB & ClientC will give

Highway (HWY)

Obviously this could be expanded in terms of the dictionary value storage to include a host of other information that may be specific to your needs, however this example shows the intent. Additionally, another enhancement would be to extend this for use in a localization scenario where multiple languages may be necessary as well.

Expression based RenderAction HtmlHelper extension (with Authorization)

Pete — Tue, 28 Dec 2010 17:39:22 +0000

        public static void RenderAuthorizedAction(this HtmlHelper helper, Expression<Action> action) where TController : Controller
        {
            var routeValuesFromExpression = Microsoft.Web.Mvc.Internal.ExpressionHelper.GetRouteValuesFromExpression(action);
 
            if(helper.IsAuthorized(action))
                helper.RenderAction(routeValuesFromExpression["Action"].ToString(), routeValuesFromExpression);
        }
 
        public static bool IsAuthorized(this HtmlHelper helper, Expression<Action> action)
        {
            var call = action.Body as MethodCallExpression;
 
            if (call == null) return false;
 
            var authorizeAttributes = call.GetAttributes<IAuthorizationFilter>();
            if (authorizeAttributes.Length == 0) return true;
 
            var controllerContext = helper.ViewContext.Controller.ControllerContext;
            var controllerDescriptor = new ReflectedControllerDescriptor(typeof(TController));
            var actionDescriptor = new ReflectedActionDescriptor(call.Method, call.Method.Name, controllerDescriptor);
 
            return authorizeAttributes.All(a => IsAuthorized(a, controllerContext, actionDescriptor));
        }

I’m sure this is coming in MVC 3, however I needed it now and it’s fairly straightforward. To use it, simply call from your View as:

<% Html.RenderAuthorizedAction(a => a.MyActionMethod()); %>

Funniest thing I’ve read in a while….

Pete — Mon, 30 Mar 2009 22:47:31 +0000

This isn’t tech related…but I am crying here after reading this. No idea if it’s true or not, but it gave me a great laugh on a day when I needed it.

First Date Gone Horribly Wrong

Color Transitions in Winform Controls

Pete — Mon, 17 Nov 2008 21:02:41 +0000

If you’ve ever used web-sites like the hosted WordPress blogs (like this one!) and others, you’ve noticed the new sweet hotness is to have screens give feedback on success or failure of an operation by showing color gradient transitions. The most common is simply “Green to White” (success!) or “Red to Pink” (failure!). This is a quick way to let the user know they can move along and do more work or whether they had an issue. Granted, more detailed logging and/or messages are needed on the “fail” side of things, however since code slingers like us write perfect code all the time….we are just gonna go with quick feedback for now

So, being as I’ve only started in the last few months writing winform/WPF apps, I thought there must be an easy way to do these gradients on forms and other controls quite easily. No so. Sure, there are ForeColor and BackColor properties, however transitioning in a gradient-like fashion from one color to the next isn’t “built in” in any way that I could tell. NOTE: Yes, I’m well aware of the fact that WPF is going to take over the world. But for now this is a Winform app, and until such time as WPF becomes the de-facto standard, it will remain as such. Accordingly, please don’t comment about how WPF can handle this with ease. I know.

So here’s what I came up with:

        public static void UpdateColor(Control ctl, Color from, Color to)
        {
            int step = 1; //Increase if you want the transition to be faster.
            var fromT = new Tuple<int, int, int>(
                Convert.ToInt32(from.R),
                Convert.ToInt32(from.G),
                Convert.ToInt32(from.B));
            var toT = new Tuple<int, int, int>(
                Convert.ToInt32(to.R),
                Convert.ToInt32(to.G),
                Convert.ToInt32(to.B));
            var curT = new Tuple<int, int, int>(fromT);
            var done = new Tuple<bool, bool, bool>(false, false, false);
 
            while (true)
            {
                //Red
                if (curT.First >= toT.First)
                    done.First = true;
                else
                {
                    var tempval = curT.First < toT.First ? curT.First += step : curT.First -= step;
                    curT.First = tempval > toT.First ? toT.First : tempval;
                }
                //Green
                if (curT.Second >= toT.Second)
                    done.Second = true;
                else
                {
                    var tempval = curT.Second < toT.Second ? curT.Second += step : curT.Second -= step;
                    curT.Second = tempval > toT.Second ? toT.Second : tempval;
                }
                //Blue
                if (curT.Third >= toT.Third)
                    done.Third = true;
                else
                {
                    var tempval = curT.Third < toT.Third ? curT.Third += step : curT.Third -= step;
                    curT.Third = tempval > toT.Third ? toT.Third : tempval;
                }
 
                if (done.First && done.Second && done.Third)
                {
                    ctl.BackColor = to;
                    ctl.Refresh();
                    break;
                }
                ctl.BackColor = Color.FromArgb(curT.First, curT.Second, curT.Third);
                ctl.Refresh();
            }
        }

So, basically I’m just getting the integer values of the RGB color scheme for the from and to colors passed in, looping through adding/subtracting from the start values (from) until I get to the end values (to), refreshing the control along the way. Not too terribly difficult, but interesting none-the-less and quite a nice little UI feature that doesn’t look like most winform applications.

Also, note I’ve added a step variable that you can tweak to adjust how fast or slow the transition occurs. It’s a pretty significant jump from say 1 to 3, so if you want more granular timing, you could adjust the int storage to decimal and account for parts of steps (such as += 0.3). Or you could implement a true timing system that would force the transition to take place within a specific time construct (perhaps the next article on this topic??). But for my needs currently, this is more than sufficient.

And of course, I’m using my handy little Tuple class, since tuples (or at least the concept of them) rock. Hint hint…please make this concept a part of C# 4.0 Anders…puuuleeeeeease?

    public class Tuple
    {
        public T1 First { get; set;}
        public T2 Second { get; set; }
        public T3 Third { get; set; }
 
        public Tuple(T1 t, T2 k, T3 l)
        {
            First = t;
            Second = k;
            Third = l;
        }
        public Tuple(Tuple t)
        {
            First = t.First;
            Second = t.Second;
            Third = t.Third;
        }
    }
 
Til next time….keep on slangin!
 

Impersonation & IDisposable

Pete — Wed, 12 Nov 2008 17:25:07 +0000

I’ve used an impersonation helper class for a while now, basically to encapsulate changing the current identity context while executing certain code. This worked well, however I always got sick of having to remember to call the “undo()” method of my current implementation once I was done with executing my code under whatever login I was impersonating.

So, I updated the class to implement IDisposable so that I can now utilize this within the using() construct provided in C#. Here’s the class in it’s entirety:

using System;
using System.Runtime.InteropServices;
using System.Security.Principal;
 
namespace Support.Win32
{
    public class Impersonate : IDisposable
    {
        public const int LOGON32_LOGON_INTERACTIVE = 2;
        public const int LOGON32_PROVIDER_DEFAULT = 0;
 
        WindowsImpersonationContext impersonationContext;
 
        public Impersonate()
        {
            //Default login is used.
            this.impersonateValidUser(“username”, “domain”, “password”);
        }
 
        public Impersonate(string username, string domain, string password)
        {
            this.impersonateValidUser(username, domain, password);
        }
 
        [DllImport("advapi32.dll")]
        private static extern int LogonUserA(String lpszUserName,
            String lpszDomain,
            String lpszPassword,
            int dwLogonType,
            int dwLogonProvider,
            ref IntPtr phToken);
        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern int DuplicateToken(IntPtr hToken,
            int impersonationLevel,
            ref IntPtr hNewToken);
 
        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool RevertToSelf();
 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        private static extern bool CloseHandle(IntPtr handle);
 
        private bool impersonateValidUser(string userName, string domain, string password)
        {
            WindowsIdentity tempWindowsIdentity;
            IntPtr token = IntPtr.Zero;
            IntPtr tokenDuplicate = IntPtr.Zero;
 
            if (RevertToSelf())
            {
                if (LogonUserA(userName, domain, password, LOGON32_LOGON_INTERACTIVE,
                    LOGON32_PROVIDER_DEFAULT, ref token) != 0)
                {
                    if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
                    {
                        tempWindowsIdentity = new WindowsIdentity(tokenDuplicate);
                        impersonationContext = tempWindowsIdentity.Impersonate();
                        if (impersonationContext != null)
                        {
                            CloseHandle(token);
                            CloseHandle(tokenDuplicate);
                            return true;
                        }
                    }
                }
            }
            if (token != IntPtr.Zero)
                CloseHandle(token);
            if (tokenDuplicate != IntPtr.Zero)
                CloseHandle(tokenDuplicate);
            return false;
        }
 
        private void undoImpersonation()
        {
            impersonationContext.Undo();
        }
 
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        ~Impersonate()
        {
            Dispose(false);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if(disposing)
            {
                //Dispose of managed resources.
                if(impersonationContext != null)
                {
                    this.undoImpersonation();
                    impersonationContext.Dispose();
                    impersonationContext = null;
                }
            }
        }
    }
}
 
Basically, now my code can use the following construct in order to execute code in an impersonated context:
 
                using(var imp = new Impersonate(“username”, “domain”, “password”))
                {
                    //Code that I want to run under this account.
                }

That’s it! Now I can be lazy and not have to worry about everything getting “cleaned up”.  What’s more, is I’ve made private the actual calls to impersonateValidUser expressly so that it forces me to use this with the using construct.  

Til next time…..keep on slangin!

LINQKit: PredicateBuilder Goodness

Pete — Tue, 28 Oct 2008 20:52:19 +0000

Remember the good ol’ days when you wanted to create a query that had dependencies that were unknown at runtime? You’d create a nice StringBuilder instance, and start building your own SQL to handle the complex logic of ever possible permutation that you allowed via your UI. Or you create the hairiest stored procedure known to man with umpteen variables and then tried not only to not screw it up internally, but to make every scenario as fast as possible. Yeah, those days were fun weren’t they?

With LINQ, such tasks are still moderately tough, but now that I’ve found the very nice PredicateBuilder class that comes in the free LINQKit, the ease with which one can create dynamic SQL calls is significantly easier.

As an example, supposed you have a table which contains a description column. And you want to implement a sort of “smart search” on that column such that if your user types in:

Include: Dog Cat
Exclude: Hamster

you code translates that into a query such as:

SELECT * FROM Pets
WHERE Description LIKE ‘%Dog%’
AND Description LIKE ‘%Cat%’
AND Description NOT LIKE ‘%Hamster%’

Behold, PredicateBuilder.

            //First get a list of keywords that match the description entered.
            string[] parts = txtInclude.Text.Split(new[] {‘ ‘});
            string[] noparts = null;
            if(txtButNot.Text.Trim().Length > 0)
                noparts = txtExclude.Text.Trim().Split(new[] {‘ ‘});
 
            var pred = PredicateBuilder.True<Pet>();
            parts.ForEach(p => pred = pred.And(pl => pl.description.Contains(p)));
            if(noparts != null)
                noparts.ForEach(p => pred = pred.And(pl => !pl.description.Contains(p)));
 
            var pets = from s in db.Pets.Where(pred)
                        select s;

Notice that it doesn’t matter what order the user types the keywords in, nor does it matter how many there are. Obviously this is a trivial example, and I don’t really have a table that stores pet names However, I do have some pretty complex requirements to create a way to backtrack and find potential buyers in our system based on previous items they’ve shown interest in. Sounds like a nice use for this gem of a find.

Til next time….keep on slangin!

LINQDataSource and Optional Parameters

Pete — Wed, 22 Oct 2008 19:20:48 +0000

The combination of LINQDataSource and GridView makes a nice quick way to provide basic search capabilities for your users. Providing a user the ability to search on multiple criteria for a single entity is quick and painless. However, I ran into an issue where one of the columns I was searching by allowed NULL in the table.

My fields looked something like:

                <tr>
                    <td>Company:  td>
                    <td><asp:TextBox ID=”txtCompNameSearch” runat=”server”>asp:TextBox>td>
                tr>
                <tr>
                    <td>Phone:  td>
                    <td><asp:TextBox ID=”txtPhoneSearch” runat=”server”>asp:TextBox>td>
                tr>

My LINQDataSource:

 
    <asp:LinqDataSource ID=”ldsCompanies” runat=”server”
        ContextTypeName=”DataContext”
        TableName=”REG_Companies” EnableUpdate=”True”
        Where=”CompanyName.StartsWith(@CompanyName) && Phone.StartsWith(@PhoneNumber)”>
        <WhereParameters>
            <asp:ControlParameter ConvertEmptyStringToNull=”false” ControlID=”txtCompNameSearch” Name=”CompanyName”
                PropertyName=”Text” Type=”String” />
            <asp:ControlParameter ConvertEmptyStringToNull=”false” ControlID=”txtPhoneSearch” Name=”PhoneNumber”
                PropertyName=”Text” Type=”String” />
        WhereParameters>
    asp:LinqDataSource>

If both CompanyName and Phone fields didn’t allow nulls, this would work just fine. However, like my scenario, the Phone field (for whatever reason) allowed NULL values in the database, this would still work but if you left txtPhoneSearch empty, it would only return records in which the Phone field was NOT NULL.

So, the next logical thing to do would be to change the ConvertEmptyStringToNull value to true for that parameter. Ah, but if you do that you get the following error when you try to load the page the code is on:

No applicable method ‘StartsWith’ exists in type ‘String’

So, this is what I came up with to fix it so you can search optionally on columns that allow nulls using the standard ControlParameter in the LINQDataSource. Leave the ConvertEmptyStringToNull=”false” as you would with non-nullable columns. However, modify your Where clause to the following:

        Where=”CompanyName.StartsWith(@CompanyName) && (@PhoneNumber == String.Empty || (@PhoneNumber != String.Empty && Phone.StartsWith(@PhoneNumber)))”>

You’re effectively just giving the query an option to exit early if the @PhoneNumber parameter is empty, but if it is not, then you’re adding the comparison to the dynamic SQL logic.

Til next time….keep on slangin!

DBML File Issue

Pete — Mon, 06 Oct 2008 19:06:09 +0000

If you edit an existing DBML file (e.g. Foo.dbml) and save it, then notice that your entire Foo.designer.cs is gone and you’re using VS 2008 SP1, then the issue (which it took me quite a while to figure out) is that you have your using statements OUTSIDE of your namespace declaration within the Foo.designer.cs AND any other partial class declarations of the Food class.

Absolutely asinine I know.

Randomization & LINQ

Pete — Tue, 30 Sep 2008 21:21:50 +0000

Ran into a problem today in which I had a List of items, and I needed to return a number X of them back, but I wanted a random sampling of the original list. There are plenty of traditional ways to do this, however I figured I’d learn something new and figure out how to do this using LINQ.

Here’s my solution, which I turned into an extension method for future use……

        public static List GetRandom(this List objs, int count)
        {
            var ret = new List();
 
            if(objs.Count() <= count)
                return objs.ToList();
 
            var used = new List<int>();
            var seq = (Enumerable.Range(1, count)
                        .Select(a =>
                            {
                                var num = (from b in Enumerable.Range(0, objs.Count()-1)
                                           orderby Guid.NewGuid()
                                           where !(from u in used
                                                  select u).Contains(b)
                                           select b).First();
                                used.Add(num);
                                return num;
                            })).ToList();
 
            foreach (int s in seq) { ret.Add(objs[s]); }
            return ret;
        }
 

Basically the thinking is that since I’m dealing with randomizing what’s in the list, I don’t really care about data specific to the type “T”. I’m just randomizing the index count from the original list based on how many I want, then using those indexes I get back from the randomization part to pull the actual objects.

The only thing I don’t like about it is the fact that I have to create a separate variable ( “used” ) to keep track of which items in the original list that I’ve already used. Seems there should be a better way to do this within the LINQ query, but at this point I am drawing a blank on that one.

Also…did you notice I am doing randomization without even using the System.Random class? Yeeaaa for me!

As always….Keep on Slangin!