DotNetKicks.com : Stories kicked by pheaven

TNValidate - A Fluent Validation Library for .NET

Tue, 12 May 2009 13:32:50 GMT

TNValidate is a fluent validation library for .Net. It allows you to write validation logic in a form that is readable both by programmers and non-programmers, but still entirely in your .Net language. TNValidate has plenty of built-in validation rules, but also provides an extension mechanism to allow you to easily add your own without having to modify the library itself. The library is released under the MIT License.

When Linq and ref Parameters Meet

Fri, 04 Apr 2008 19:07:53 GMT

In this post we look into a curious quirk of C#: you can't use parameters passed as "ref" inside a Linq query (or a lambda expression or anonymous method either). By analysing the intermediate code produced by the C# compiler, we learn how anonymous methods are compiled when they need lexical scoping semantics. Finally, an attempt to change the IL to get the desired semantics reveals why C# forbids this.

Very Quick Guide To DLinq: Part 2

Fri, 04 Apr 2008 19:05:34 GMT

In the second part of our series to quickly get you up and running with DLinq, we look at using it to do insert, update and delete queries. Includes simple code examples to show you how to do it.

Very Quick Guide To DLinq: Part 1

Mon, 17 Mar 2008 13:07:43 GMT

The first part of our series on DLinq, this post illustrates the steps involved in creating the LINQ to SQL classes using Visual Studio 2008. It then looks at how to use them to write a simple query on the database and iterate over the results.

Float, Double and Decimal: do you know the differences?

Tue, 11 Mar 2008 21:05:42 GMT

There are a number of data types available in the .Net framework for storing numbers with fractional parts. They are each appropriate for different situations, and using the wrong one can lead to errors in calculations as well as performance issues! Learn which one you should use when.

Can a language make programming more fun?

Mon, 03 Mar 2008 22:31:59 GMT

When it comes to choosing a programming language, there is plenty of personal preference involved. This post considers a few reasons that might make people prefer one language over another. It then asks how much personal preference matters, and how much weight should be put on it when deciding which language to use.

Google Trends of Programming Languages

Mon, 03 Mar 2008 20:52:09 GMT

Google Trends shows the popularity of search terms over a period of time and allows you to compare how many searches are being performed on various terms. This post looks at the result of querying Google Trends on various programming languages, and considers whether we can use this data to say anything at all about the relative popularity of different programming languages.

Do try...catch blocks hurt runtime performance?

Wed, 20 Feb 2008 23:31:02 GMT

This posts looks at the real runtime cost of writing a try...catch block in a .Net language. Drawing on his knowledge of .Net internals, the author looks at how such structures are represented in a compiled .Net assembly and what happens at runtime, so the performance characteristics can be understood.

C#.NET or VB.NET?

Tue, 12 Feb 2008 05:28:21 GMT

Recently we got a question from a user asking which of C# and VB.NET was best suited to developing commercial applications like Payroll systems. In this post we look at the similarities and differences between the languages and pick out some of the things that may be worth considering when making the decision.

What is REST, anyway?

Thu, 07 Feb 2008 05:51:30 GMT

In this article, we explain REST (Representational State Transfer). It's an approach to building distributed systems, though less commonly used than Remote Procedure Calls. We look at what it is, how it differs from RPC, when it might be suitable to use it and what lessons we can learn from it.

Divvy up my list? Aye!

Fri, 01 Feb 2008 17:20:47 GMT

What happens when you mix Yorkshire slang with the new features in C# 3.0? A useful extension method for categorizing Lists, it seems. This article provides an example of how you can use generics, lambda expressions, extension methods and collection initializers together and get something useful, compact and still readable as a result.

Higher Order Programming Is Easy!

Thu, 31 Jan 2008 15:30:12 GMT

Higher Order Programming is one of those things that to many people sounds weird, magical, mysterious or just too hard for them to be able to do. It's not, and you have likely done it without realizing it. This article takes a quick look at the paradigm, using a couple of short examples.

Why automated testing matters

Thu, 17 Jan 2008 17:22:36 GMT

This blog post discusses a couple of the author's experiences with automated testing, and takes an honest look at how well it worked out. It then goes on to cover how to jump into automated testing of your own projects, suggesting tools and some best practices.

What are the next generation of programmers learning?

Tue, 15 Jan 2008 18:12:35 GMT

What does it take to be a good programmer, and are computer science courses providing that to today's students? This post takes a quick look at the key things that really should be on a computer science course, and discusses what the overall aim of the course should be: not just turning out code monkeys in today's hot languages, but scientists who can effectively use (or create) the tools and languages that are available in a couple of decades time.

Introducing C# 3 - Part 4

Thu, 13 Dec 2007 17:13:13 GMT

This is the final part of a series on C# 3.0. It covers Linq - Language Integrated Query. It explains what declarative programming is, how Linq fits in with this paradigm and why it is a good thing, before explaining how to write Linq queries using a variety of basic and advanced features. Finally, the architecture of Linq is examined, with some notes on DLinq and XLinq.

Introducing C# 3 - Part 3

Thu, 13 Dec 2007 17:13:00 GMT

This is the third of a four part series on C# 3.0. It covers new features that will help you to build data structures more easily, including object and collection initializers. It then moves on to anonymous types, which are useful in Linq, and how type equivalence works with anonymous types.

Introducing C# 3 - Part 2

Thu, 13 Dec 2007 17:12:45 GMT

This is the second of a four part series on C# 3.0. It covers extension methods, explaining what they are, when to use them and how to write them. It then moves on to lambda expressions, explaining the syntax and showing how C# 2.0 anonymous methods can be re-written using the new syntax. It also looks at how type inference and lambda expressions work together.

Introducing C# 3

Thu, 13 Dec 2007 17:08:02 GMT

This is the first of a four part series on C# 3.0. It covers type inference, also known as implicitly typed variables. It explains what type inference is, why it is useful and the performance consequences of using it. It also looks at implicitly typed arrays.

Webmaster Checklist - How Does Your Site Do?

Thu, 27 Sep 2007 03:34:40 GMT

About to deploy a site? Find out what you've forgotten to do! We have collected together numerous tried and tested tips to make the ultimate webmaster checklist. It includes detailed tips on search engine optimization, accessibility, security, page download time, privacy and legal issues, hosting and more. There is also a downloadable tick-list version of the checklist, so you can tick off each item as you check it for your site.

2006 At Programmer's Heaven: The Highlights

Thu, 21 Dec 2006 19:13:02 GMT

As another year draws to a close and the Programmer's Heaven team take a break for Christmas, it's time to take a look back over the year that's just been.

Free C# School Ebook

Tue, 12 Dec 2006 11:31:01 GMT

This free 330 page ebook covers the .NET framework and the C# language. Starting with the basics of the language, it goes on to cover object oriented programming techniques and a wide range of C# languages features including interfaces, exceptions and delegates. Later chapters cover practical topics including database access with ADO.NET, building Windows forms applications, multi-threading and asynchronous I/O. The final chapter covers new features in C# 2.0, including generics.