Cale Dunlap » c#

LINQ Audit Trail v2 – DoddleAudit

Cale — Wed, 30 Dec 2009 04:29:17 +0000

This looked like a link that was fairly re-post worthy. This is practically a must for any .NET + LINQ + MSSQL developer out there. Very neat way of doing audit trails in MSSQL with LINQ and C#.

A couple months ago I wrote a basic set of extension methods to handle automatic auditing in LINQ to SQL. Well I have received a large number of emails regarding this particular project so I have decided to focus on cleaning up my v2 API and releasing it on CodePlex. There was a lot of room for improvement from version 1 and today I am going to post the all new LINQ Audit Trail code. This new version is significantly enhanced in the previous version.

via LINQ Audit Trail v2 – DoddleAudit.

Helpful Extension Methods to the System.String Class in C#

Cale — Mon, 26 Oct 2009 10:20:03 +0000

I’ve been doing a decent amount of string manipulation lately and decided to combine that with my newfound knowledge about .NET extension methods. If you don’t know what extension methods are, they’re basically a way to extend a class without needing the source code to that particular class–hence why I can extend the System.String type by simply writing another class. The key is with the parameters of your methods. Here’s the basic gist of it:

public static {Your Return Type} {Your Method Name} ( this {Type/Class you want to extend} {Parameter Name} )
 {
      /* Your method body */
 }

So the key here is the “this” keyword before the type identifier in the parameter list of the method.

I’ve wrapped all of my extension methods into a single class simply called “ExtensionMethods” and added it to my project. The namespace doesn’t matter, so I haven’t included it in this example. You can either use the global namespace (though I don’t recommend it) or just create your own namespace called whatever you want.

Without further adue, here’s the code:

publicstaticclassExtensionMethods

{
/// 

    /// Includes the trailing path delimiter.

    /// 
/// The input path.
/// The input path including a trailing path delimiter if it doesn't have one
publicstaticstring IncludeTrailingPathDelimiter(thisstring InputPath)

    {
if (!InputPath.EndsWith(Path.DirectorySeparatorChar.ToString()) &&

            !InputPath.EndsWith(Path.AltDirectorySeparatorChar.ToString()))
return InputPath + Path.DirectorySeparatorChar;
return InputPath;

    }
    /// 


    /// Asserts the trailing path delimiter.

    /// 
/// The input path.
publicstaticvoid AssertTrailingPathDelimiter(thisstring InputPath)

    {

        InputPath = InputPath.IncludeTrailingPathDelimiter();

    }
    /// 


    /// Trims the extension from a file name.

    /// 
/// The input file.
publicstaticvoid TrimExtension(thisstring InputFile)

    {
int start, count;
if ((start = InputFile.LastIndexOf(".")) > 0)

        {

            count = InputFile.Length – start;

            InputFile = InputFile.Remove(start, count);

        }

    }
    /// 


    /// Gets a file extension of a filename.

    /// 
/// The input file.
/// The file extension
publicstaticstring FileExtension(thisstring InputFile)

    {
int start, count;
if ((start = InputFile.LastIndexOf(".")) > 0)

        {

            count = InputFile.Length – start;
return InputFile.Substring(start, count);

        }
returnstring.Empty;

    }
}

Now whenever you use a System.String object, you’ll be able to simply call these methods as if they were part of the System.String class. IE: string MyFileExtension = MyFilePath.FileExtension();

I’m sure I’ll add on to this as I go along.

Templatize Tool

Cale — Sat, 18 Jul 2009 06:52:31 +0000

I recently wrote up a template engine tool called Templatize. It started as a tool for my girlfriend so she could quickly generate HTML pages from CSV rows for use on eBay, but then quickly grew into a more robust template tool.

Basically it takes a set of input data, containing multiple entities (rows), each with multiple properties (columns), formatted from some type of delimited text file. Then it takes in a master template file and spits out multiple “data-injected” versions of that template.

View the full page here.

KnowIT RC2.1 Released

Cale — Mon, 18 May 2009 14:02:37 +0000

I’ve completed the modifications and package builds for KnowIT releast candidate 2.1. They are available from the KnowIT Google Code site. Dare I say, this is one of the best peices of software I have written in a long time. And the best part is, its open source!

Check out the Screenshots.

KnowIT works with Windows ONLY. There is currently not a Linux/UNIX scanner available for KnowIT, and the database back-end is a Microsoft product (MSSQL 2005). However, I did add ODBC support this time around, so it may work on other database types as well. If anybody gets it to work on MySQL or Oracle, let me know.

VGL Math – 2D/3D Video Game Math Library

Cale — Wed, 25 Mar 2009 10:05:25 +0000

I decided to get bold and start another open source project. This time it is related to the math involved in developing 2D and 3D video games. The project is hosted at http://code.google.com/p/vglmath. I decided to deem it a “VGL community project”; VGL being the company I founded a few months ago.

I’m looking for any pointers, contributors, or experts to make improvements or recommendations to the code. So please check it out. If you’re interested in contributing, please send me an email at cale@caledunlap.com so I can add your Google account to the members list.

And if you haven’t already, check out http://www.venomgamelabs.com!

Now for your entertainment for the evening:

Angel Progress!!!!

Cale — Tue, 23 Dec 2008 12:35:13 +0000

So, I spent all day yesterday and already a little bit this morning working on Angel. Angel went from a service-only proof-of-concept to a server and client proof of concept in just under 12 hours. I’ve been stress-testing it a little bit this morning and it ran 10,000 “AddUser” commands in just under 3 minutes. Sounds slow? Well, let me explain everything that goes on in a single “AddUser” command (subject to change):

Build the SOAP request (translate Angel data objects to SOAP-compatible objects). Request contains user information (Name, Alias, etc.)
Connect to the Angel web service
Send the command parameters to the web service
Service writes a log entry to a text file (very verbosely)
Service executes a database statement, storing the data
Service checks for errors, if none, grab the user ID back out of the database (room for optimization here). If errors occured, put error description into the response object.
Service builds a response object and sends it over the wire back to the client
Client converts the SOAP-compatible object back to Angel data object types
Client checks the response object for success/failure from the server
Client tears down SOAP connection

Now do that 10,000 times.

This is my first time building a C++ SOAP client and I must say, with the help of gSOAP, it works great. It is the first time I’ve gotten a C# web service and a C++ client to play nicely together. We initially tried this with raw sockets, but it proved to be WAY too much of a hassle and there’s too much that could go wrong. This has worked 1000% more reliably than anything else I’ve tried. I’ve sort of been having that “mad scientist” feel about me the last few days since I’ve gotten this work–talking to myself, mumbling, swearing at my code, and then screaming “IT’S ALIVE!!!!!” when it finally worked.

KnowIT Releases First Version

Cale — Wed, 17 Dec 2008 08:01:46 +0000

Ok, so even though I didn’t get ALL of the bugs hammered out in KnowIT, I released a preliminary version of it over at Google Code. It hasn’t been reviewed yet by anybody, and I even have yet to install it from the installers I built, so I’m honestly not even sure if it will work. But regardless, I’ve tagged it as a release in SVN and I’ll probably be continuing to make improvements and modifications to it here and there. I just wanted it to get out the door so I could stop having that monkey on my back. Monkeys get heavy after a while.

CHALLENGE: Find my heap corruption

Cale — Sun, 05 Oct 2008 04:20:07 +0000

Alright, I’ve been fighting with some heap corruption for the last month or so with the Angel re-write I’ve started. The heap corruption is occurring in the client library test program, meaning the source is probably in the client library itself.

Here’s the source for the test program:

#include"AngelClient.h"
 void main()
 {
     AngelKV *kv = new AngelKV(L"data");
     kv->AddKV(L"Name",L"Cale Dunlap");
     kv->AddKV(L"Age",L"24");
     kv->AddKV(L"Alias",L"Mazor");
     AngelClient pClient = AngelClient("pantera","angeltest","angeltest");
     AngelResponse *pResponse = pClient.RunCommand( L"AddUser", kv );
     if( pResponse != NULL )
         delete pResponse;
     pClient.Disconnect();
 }

The heap corruption is occurring in the default destructor of the AngelClient class. Here is the full source to the Angel Solution. The visual studio project/solution is for Visual Studio 2008. There’s a server and client written in C#, but right now I’m focusing on the client written in C++. I’m tempted to pay a reward to the person who finds it. If you happen to come across this post and find where my heap corruption is coming from, drop me a line at cale@caledunlap.com.

The error messages:

Things I’ve tried so far:

Replaced the socket library 3 times thinking it was something within the socket library
Rewrote the client class twice
Used STL for the linked lists and strings to remove any errors I may have put in doing the linked listing and string handling myself
Undid the STL stuff for the string handling because that obviously didn’t fix it, plus I was getting even more weirdness with using STL anyway, so it was a step in the wrong direction to begin with. There’s still a little bit of STL string stuff in there, but only for splitting key/value pairs.

I’m at wits end with this, and I need some help. Thank you.