Angelos Petropoulos' WebLog

Get a decimal that is not padded with zeros in SQL Server 2005

angelosp — Wed, 26 Nov 2008 16:14:00 +0100

In SQL when you convert anything to a decimal you have to provide the number of decimal places as part of the conversation. For example

DECLARE @NumberAsString VARCHAR(20)
SET @NumberAsString = '1038.93801'

DECLARE @NumberAsDecimal DECIMAL(28.10)
SET @NumberAsDecimal = CONVERT(DECIMAL(28,10), @NumberAsString)

If you execute SELECT @NumberAsDecimal what you get back is '1038.9380100000'. The reason why the result is padded with zeros is because the number of decimal places specified during the conversion is 10. Such a result can look very ugly in reports.

In SQL server 2005 there is no easy way to get rid of extra zeros. The fastest and simplest way I know is the following

CREATE FUNCTION GetNonPaddedDecimal
(
@number Decimal(38,10)
)
RETURNS VARCHAR(max)
AS BEGIN
RETURN REPLACE(RTRIM(REPLACE(REPLACE(RTRIM(REPLACE(@number, '0', ' ')), ' ', '0'), '.', ' ')), ' ', '.')
END

Thanks to Ashar for coming up with it

(Interfaces && DI == Design.Good) does not always return true

angelosp — Wed, 30 Apr 2008 09:38:00 +0100

I have previously stated my reservations regarding Extensions methods, however this Eli Lopian's post still makes a good read.

WinXP SP3 available in MSDN

angelosp — Thu, 24 Apr 2008 13:24:00 +0100

Those of you who have an MSDN subscription should be able to get WinXP SP3 by navigating to the "Top Subscriber Downloads" part of the MSDN home page (scroll at the bottom).

The link is labelled Windows XP Service Pack 3 (x86) - CD (English)

Update: It's worth noting that if for some reason you don't want Windows Update to install WinXP SP3 automatically, you can block it.

A more straightforward Microsoft Unity quickstart

angelosp — Tue, 22 Apr 2008 14:54:00 +0100

I recently downloaded and started playing with Unity, trying to see if it fits our project's needs. You can grab the installer from CodePlex, which also includes a couple of quickstarts.

Personally I found the bundled quickstarts too advanced and complicated for someone that hasn't used IoC frameworks before. In my opinion they try to demonstrate too much functionality at once. In any case, I decided to create a small project that would put Unity to use and I thought I'd share it here, as others may find it useful.

Enjoy

Simple Unity Quickstart.zip (23.13 kb)

ThreadPool - More threads per CPU, more memory consumed ... possible gotcha!

angelosp — Mon, 03 Dec 2007 10:46:00 +0100

So you know how the actual CLR hasn't changed since .NET 2.0? That is not entirely true (i.e. the one for Vista is a different build number), especially when you consider the .NET 3.5 release. The cut a long story short, Microsoft has taken the opportunity to include a service pack for the .NET CLR 2.0, which is a great thing as we are getting fixes for some annoying bugs.

One of the changes in SP1 of the CLR is the increase of the max number of threads per CPU that the .NET ThreadPool supports. It used to be 25 per CPU and the number has now increased to 250. Richard Blewett points out how this could be a potential gotcha as more threads means more memory consumed and ... well read the post! It's something not very likely to happen, but definitely worth knowing about. Plus, he talks about what brought this change, which is always interesting to know.

Using XML as a datatype in SQL Server 2005

angelosp — Wed, 28 Nov 2007 22:14:00 +0100

There are many articles and posts out there that describe the XML capabilities of SQL Server 2005. Some of the top links are

The Fundamentals of the SQL Server 2005 XML Datatype
XML Support in Microsoft SQL Server 2005
Introduction to XQuery in SQL Server 2005
Denis Ruckebusch's blog

The only problem is that you need to work rather hard to put all of this information together before you can get a decent working example. I went through this excercise myself, so I thought it would be worth posting it here. The example is simple, I want to store an XML in one of my columns and I want the XML to be typed (i.e. to adhere to a schema). The first step is to define the schema for the XML file and to import it into SQL Server 2005.

The schema defines the following structure

Order
    OrderItem
        Name
        Price
        Quantity

Importing the schema into SQL server is pretty simple, just use following T-SQL statement

CREATE XML SCHEMA COLLECTION [dbo].[OrderCollection] AS
'<?xml version="1.0" encoding="utf-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="Order">
    <xsd:complexType>
      <xsd:complexContent mixed="false">
        <xsd:restriction base="xsd:anyType">
          <xsd:sequence>
            <xsd:element minOccurs="0" maxOccurs="unbounded" name="OrderItem">
              <xsd:complexType>
                <xsd:complexContent mixed="false">
                  <xsd:restriction base="xsd:anyType">
                    <xsd:sequence minOccurs="0">
                      <xsd:element name="Name">
                        <xsd:complexType>
                          <xsd:simpleContent>
                            <xsd:extension base="xsd:string" />
                          </xsd:simpleContent>
                        </xsd:complexType>
                      </xsd:element>
                      <xsd:element name="Price">
                        <xsd:complexType>
                          <xsd:simpleContent>
                            <xsd:extension base="xsd:decimal" />
                          </xsd:simpleContent>
                        </xsd:complexType>
                      </xsd:element>
                      <xsd:element name="Quantity">
                        <xsd:complexType>
                          <xsd:simpleContent>
                            <xsd:extension base="xsd:integer" />
                          </xsd:simpleContent>
                        </xsd:complexType>
                      </xsd:element>
                    </xsd:sequence>
                  </xsd:restriction>
                </xsd:complexContent>
              </xsd:complexType>
            </xsd:element>
          </xsd:sequence>
        </xsd:restriction>
      </xsd:complexContent>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>'

Using SQL Server Management Studio you can confirm that the XML Schema is now available to be used by navigating to the "Types" node as shown below

It is now possible to create a table and define one of its columns to be of the datatype XML and to ensure that the XML inserted into the column is validated against the schema we just added using the following T-SQL statement

CREATE TABLE [dbo].[Order](
    [ID] [bigint] IDENTITY(1,1) NOT NULL,
    [CustomerID] [bigint] NOT NULL,
    [Value] [xml](DOCUMENT [dbo].[OrderCollection]) NOT NULL
)

Inserting a record into the new table is still exactly the same as before, with the only difference now that one of the parameters will be an XML document

INSERT INTO [Order]
(
    [CustomerID],
    [Value]
)
VALUES
(
    1625,
    '<Order>
      <OrderItem>
        <Name>Chair</Name>
        <Price>12.99</Price>
        <Quantity>4</Quantity>
      </OrderItem>
      <OrderItem>
        <Name>Table</Name>
        <Price>44.99</Price>
        <Quantity>1</Quantity>
      </OrderItem>
    </Order>'
)

Now comes the interesting part. Of course you can now select this record within your application code and manipulate the XML using the standard libraries, but what if you want to access this information within SQL Server (perhaps through an ordinary stored procedure). Another possibility is that you would like to perform some reporting on the data that is stored within the XML document.

The following T-SQL will turn the XML file into tabular format, with columns for each element that contains a value (i.e. the elements "Name", "Price" and "Quantity") and a new row for each instance of the element "OrderItem".

-- Declare a variable of type XML
DECLARE @xml XML

-- Assign the value of the XML document
-- we want to manipulate to the variable @xml
SELECT
    @xml = [Value]
FROM
    [Order]
WHERE
    ID = 1

-- Present the data in tabular format
SELECT
    -- Select the element "Name" and convert its value to a VARCHAR(100)
    OrderItemFragment.Details.query('Name').value('.', 'VARCHAR(100)') AS [Name],
    -- Select the element "Price" and conver its value to DECIMAL(28,2)
    OrderItemFragment.Details.query('Price').value('.', 'DECIMAL(28,2)') AS [Price],
    -- Select the element "Quantity" and convert its value to INTEGER
    OrderItemFragment.Details.query('Quantity').value('.', 'INTEGER') AS [Quantity]
FROM
    -- Split the XML document into individual pieces, one for each
    -- instance of the element "OrderItemFragment". Name the tabular result
    -- "OrderItem" and give its single column the name "Details"
    @xml.nodes('/Order/OrderItem') AS OrderItemFragment([Details])

The code is not really that complicated, but there are some rules.

The function ".nodes()" used to split the XML file into fragments cannot be performed on value of the datatype XML. ~~The reason I am selecting the XML file that I want to manipulate into a local variable first is to work around this limitation. I tried long and hard, but I could not get "Order.Value.nodes()" to work~~. (see "Update 29/11/2007")
The output of the function ".nodes()" is tabular and has to be named and its columns have to be specified.
The output of the function ".nodes()" can only be accessed through SQL XML functions such as ".value()", ".query()", ".count()", etc.

The line "@xml.nodes('/Order/OrderItem')" navigates through the XML document by first finding the element "Order" and then the element "OrderItem". Every time it comes across this relationship of elements (i.e. "Order" is parent and "OrderItem" is child) it seperate it from the rest of the document and returns an XML fragment that is the contents of the "OrderItem" element it has identified. The result of the XQuery statement is the collection of these XML fragments.

The line "OrderItemFragment.Details.query('Name').value('.', 'VARCHAR(100)') AS [Name]" uses the ".query()" function to find the element called "Name". It then uses the function ".value()" to retrieve the identified element's value and convert it to a SQL datatype.

The result are exactly what you would expect a T-SQL statement to return

Update 29/11/2007: There had to be a way and sure enough I found it. You can use the ".nodes()" function on an XML columns straight in the "FROM" part of the statement rather than having to user a variable. The previous SQL statement is equivalent to this one

SELECT
    OrderItemFragment.Details.query('Name').value('.', 'VARCHAR(100)') AS [Name],
    OrderItemFragment.Details.query('Price').value('.', 'DECIMAL(28,2)') AS [Price],
    OrderItemFragment.Details.query('Quantity').value('.', 'INTEGER') AS [Quantity]
FROM
    [Order] CROSS APPLY [Value].nodes('/Order/OrderItem') AS OrderItemFragment([Details])
WHERE
    ID = 1

Persisting .NET DateTime

angelosp — Mon, 19 Nov 2007 20:08:00 +0100

In a previous post I pointed out how .NET's DateTime and SQL Server's DateTime have different percisions and comparing two instances of what was originally the same value could result in a mismatch. I also provided a solution that uses a BIGINT field in SQL Server to store the value as ticks and a user defined function to convert them to SQL's DateTime and back.

The problem with that solution is the extra processing that is required for performing the simple task of saving and loading a date and time value. This becomes an issue when dealing with a large amount of data, such as in the case of rendering of a historical report for example. There is an alternative that eleviates the need for any extra processing when saving and loading the value, but its a compromise.

The difference in percission is minor (only at the millisecond level). Looking at the situation pragmatically, in most scenarios it doesn't really matter. We rarely deal with time down to the level of milliseconds, typically seconds are more than enough. If the milliseconds are ommited both in .NET and in SQL Server, then there is no discrepancies between the values. This means that there is some data loss as milliseconds are removed from the date and time, but if they were not needed in the first place then this is not necessarily a problem.

The following method can be used to strip the milliseconds off a .NET DateTime

public static DateTime PrepareForSql(DateTime dateTime)
{
return new DateTime((long)
Math.Floor((decimal)dateTime.Ticks / 10000000) * 10000000);
}

Update: To those that know me it won't be a surprise, but I'm dumb. I thought I was being clever by using .Ticks and Math.Floor, when just doing the following has exactly the same effect and it is more performant

public static DateTime PrepareForSql(DateTime dateTime)
{
return new DateTime(dateTime.Year, dateTime.Month, dateTime.Day,
dateTime.Hour, dateTime.Minute, dateTime.Second);
}

Run #10
TestNewDate 00:00:00.1702448
TestNewDateUsingTicks 00:00:00.2002880

The VS2008 effect - MSDN funky error message

angelosp — Mon, 19 Nov 2007 16:55:00 +0100

A co-worker came across this error today

Looks like someone went live with an update to the source code and forgot to deploy some of the referenced DLLs.

BTW remote debugging is enabled ... uncool MS, uncool!

SQL Server 2008 - Intellisense finally included

angelosp — Mon, 19 Nov 2007 10:26:00 +0100

All I can say is, finally!

I've used 3rd party tools in the past to get intellisense support within Query Analyser and SQL Server Management Studio, but to be honest they don't quite work. Sometimes the auto-complete list does not show up, other times it does things you didn't want it to do such as insert the first item from the list because you pressed tab even though all you meant to do was indent the text, etc.

With all these different naming convensions enforced on developers, typically authored by people that never actually write SQL and their goal is to define every aspect of a database object within its name (e.g. transTblCustomer.bigintCustomerID kill me now), this is more than just a nice to have.

TechEd Wisdom – Still not convinced about LINQ

angelosp — Fri, 16 Nov 2007 08:02:00 +0100

First of all, let’s get something straight. LINQ is not SQL. LINQ is a query framework integrated to the language. What it queries is irrelevant and could be pretty much anything (which is why you have all these specific implementations such as LINQ to SQL, LINQ to XML, LINQ to SharePoint, etc). The only thing that LINQ and SQL have in common is similarity in syntax.

With that out of the way, let’s talk “advantages” (I also did the air-quote thing as I typed this).

Unified way of accessing different types of data

*cough*bullshit*cough*. We have been drinking this cool aid for years now. Wasn’t this the tag line for ADO.NET as well when it was first introduced? The reality is that you build an application and you either connect to a database or use XML files. You will not switch between the two because someone raised a change request.

I don’t care that I can use LINQ to query both XML and relational data. I am happy to use SQL for one and XPath for the other. Just as I am happy to write my own code to query proprietary text files and third party libraries to query PDF files. I just don’t care because in the real world it adds no value. If I have been using LINQ to SQL for 3 years it does not mean I also have 3 years of experience in LINQ to XML. I still don’t have a clue what the best practices and related architectural decisions are around using XML.

Look at it pragmatically. When was the last time you wanted to write a SQL-like statement to access your collection of objects or XML file? Personally I can’t even remember, but if the occasion does arise, I will write a method that does it and re-use it; big deal. You see these examples on the internet where they create a class scope array with random data and then use LINQ to find the item that has a length greater than 3 and then order the results alphabetically. Are you kidding me? God, you are not kidding. OK, a couple of questions

In a production system, where is the data held? The answer 99.9% of the time is a database.
In a production system, would you load random data from the database, get it through all the tiers and then do your calculations/filtering/etc. in the front end tier? If you answered yes, I don’t want to ever use your code or have you in my dev team; you are terrible.

Disclaimer: There will always be that one in a thousand situations where something unorthodox is required to make a very specific solution work. I don’t care. We are discussing a feature that has been embedded to the programming language itself. This is not about the exceptions; this is about the general rule.

Support within the IDE with intellisense and compile time checks

Well last time I checked, all code does. Why on earth is this considered an advantage? Its an advantage over using something terrible like scripting, sure, but this is effectively lowering the standards so you can brag about something that in reality is a given. Who would be happy using something new that does not provide you with intellisense, does not type check and only has run-time error checking? Even the JavaScript developers won’t have to put up with that when using VS 2008.

You don’t have to write SQL!

Clearly this is only applicable to LINQ to SQL and not LINQ in general. I’m addressing it because it makes up the biggest *wow* factor in the eyes of most developers who can’t wait to get their hands on LINQ.

So, what do you gain by using LINQ to SQL?

You don’t have to write T-SQL (yes T-SQL, because LINQ to SQL only works with SQL Server) and you save time and effort!
You have intellisense and compile time checking!
Umm…that’s about it

Let’s look at real world applications and enterprise scale applications that use a database back end. Does the database expose its tables and then the application executes dynamic T-SQL at run-time? If you answered yes, shoot yourself now and preferably in the head. Do it, I’ll wait. The database is locked down as much as possible. You use stored procedures as a façade between the data access layer and the data. This way you can lock down access, you can ensure there is no way SQL injection can ever take place no matter how stupid the application is, etc. So it turns out, you have to write exactly the same amount of T-SQL as you did before, regardless if you use LINQ to SQL or not.

Now, you have your data within your application. Do you use datasets to hold your data? You said yes didn’t you? I thought I told you to shoot yourself. Data is stored in business entities so that validation can take place and business rules can be applied. So both the business and the data access layer remain unchanged regardless whether LINQ to SQL was used or not.

So you have written all this code you would write if you did not use LINQ to SQL and now … well now you have to write more code so that you can use this cool thing called LINQ. Except there is no point using LINQ now as you have loaded your data from the database, you have already created business entities, applied the validation and business rules and the job is done. Where was LINQ useful in any part of this process? And please don’t say that you might want to do filtering and further data manipulation at the presentation layer because I will shoot you myself.

Why am I bitching so much?

LINQ has polluted .NET

The languages and .NET in general have been polluted by LINQ. Over 90% of the features added to .NET 3.5 are to accommodate LINQ and most of them are terrible or just not necessary. I’m not the only one who thinks so either.

So if I don’t like something I should just not use it and shut up right? I would if I could. Unfortunately I develop enterprise level applications for a living. This, more often than not nowadays, means large development teams and use of outsourcing. I have to make a system that is developed by 30 different developers of a different background and competence level, consistent and supportable with readable source-code. With extension methods that can take over class functionality from anywhere and type inference combined with lambda expressions that allow you to write hundreds of lines of completely unreadable and un-maintainable code, my professional life has just turned into hell.

Update: This is an exhaggeration of course to prove a point, but still ...

TechEd Wisdom - ASP.NET MVC Framework

angelosp — Wed, 14 Nov 2007 13:11:00 +0100

I was going to write something up for the ASP.NET MVC Framework today, but thankfully I checked my feeds before I did that. Turns out that Scott Guthrie has already done this and did it much better than I would have done it. Its a massive post, but very detailed and should give you a good feel what the framework is about.

Just some key points to summarise in case you can't be bothered or don't have time to read the whole post

New model for building web sites
No post back (that's right ... no forms, no nothing)
Simple HTML outputed; the rendering engine doesn't really need to be ASP.NET for the framework to work
No need for complex server side controls such as GridView (because there is no post back)
Very modular, almost everything can be extended/replaced
Could use AJAX with it, but not much point
Everything is driven off the URL which dictates what action will be performed by the "Controller"
With the logic being encapulated in the "Controller" testing can reach ~100% code coverage simply with unit tests without using web test automation applications

It looks like an interesting idea, but I am not sure how "commercial" it is. I am also not certain how well it scales as it does not allow you to take advantage of the ASP.NET asynchronous programming models (will write about them soon)

TechEd Wisdom - Common Table Expressions

angelosp — Wed, 14 Nov 2007 05:56:00 +0100

This is the first of a series of posts on the stuff I learnt at TechEd. Some of it is brand spanking new and some of it, like this one, may not be so new but definitely overlooked (at least by myself anyway).

Common Expression Tables were introduced in SQL Server 2005, so this is not a SQL Server 2008 feature. They may seem a bit pointless at first, but they are in fact awesome.

So a simple example would be

WITH SimpleCTE (ProductName, Price) AS
(
SELECT 'Chair', 5.5
)
SELECT * FROM SimpleCTE

ProductName Price
----------- -------
Chair 5.5

We define a CTE using the keyword WITH called SimpleCTE. It has two columns, ProductName and Price. Notice that it is not necessary to specify the type of the columns. The data for the CTE is a very simple SELECT statement of two values. The most important part is actually the line that follows the definition of the CTE, the statement that selects all the rows of the CTE. The reason it is so important is because it highlights the nature of CTEs, which is that they are completely dependant on the statement that follows them. What do I mean about that? Highlight all of the above code and execute as part of a query. Everything works are normal. Now highlight only the definition of the CTE omitting the last SELECT statement and execute again. You get an incorrect syntax error. That’s because CTE cannot exist on their own, they can only exist as part of another SQL statement.

Right, so you can have pretty much anything you like inside your CTE; for example

WITH SimpleCTE(ID, [Name], Parent) AS
(
SELECT * FROM Category
)
SELECT * FROM SimpleCTE

ID                   Name                      Parent
-------------------- ------------------------- -------
1                    Software                  NULL
2                    Hardware                  NULL
3                    Games                     1
5                    Business                  1
6                    Motherboards              2
7                    CPUs                      2
9                    Children Games            3
10                   Strategy Games            3
11                   Small Business            5
12                   Enterprise                5
13                   ATX Motherboards          6
14                   Mini ITX Motherboards     6
15                   Intel CPUs                7
16                   AMD CPUs                  7

WITH SimpleCTE(ID, [Name], Parent) AS
(
SELECT * FROM Category WHERE Parent IS NULL
)
SELECT ID, Name FROM SimpleCTE

ID                   Name
-------------------- -------------------------
1                    Software
2                    Hardware

WITH SimpleCTE(ID, [Name], Children) AS
(
    SELECT
        ID,
        Name,
        (SELECT
            COUNT(*)
         FROM
            Category ChildCategory
         WHERE
            ChildCategory.Parent = Category.ID
        ) AS Children
    FROM
        Category

)

SELECT ID, [Name], Children FROM SimpleCTE

ID                   Name                      Children
-------------------- ------------------------- -----------
1                    Software                  2
2                    Hardware                  2
3                    Games                     2
5                    Business                  2
6                    Motherboards              2
7                    CPUs                      2
9                    Children Games            0
10                   Strategy Games            0
11                   Small Business            0
12                   Enterprise                0
13                   ATX Motherboards          0
14                   Mini ITX Motherboards     0
15                   Intel CPUs                0
16                   AMD CPUs                  0

In a sense, CTE are very much like views created on the fly. The SQL statement that follows it is based on the data provided by the CTE. Things get interesting when you want to perform recursion

WITH SimpleCTE(ID, [Name], HierarchyDepth) AS
(
    SELECT
        ID,
        [Name],
        1 AS HierarchyDepth
    FROM
        Category
    WHERE
        Parent IS NULL

    UNION ALL

    SELECT
        c.ID,
        c.[Name],
        SimpleCTE.HierarchyDepth + 1 AS HierarchyDepth
    FROM
        Category AS c
        INNER JOIN SimpleCTE ON c.Parent = SimpleCTE.ID

)
SELECT
   ID,
   [Name],
   HierarchyDepth
FROM
   SimpleCTE
ORDER BY
   HierarchyDepth

ID                   Name                      HierarchyDepth
-------------------- ------------------------- --------------
1                    Software                  1
2                    Hardware                  1
6                    Motherboards              2
7                    CPUs                      2
3                    Games                     2
5                    Business                  2
11                   Small Business            3
12                   Enterprise                3
9                    Children Games            3
10                   Strategy Games            3
15                   Intel CPUs                3
16                   AMD CPUs                  3
13                   ATX Motherboards          3
14                   Mini ITX Motherboards     3

CTEs are able to join on themselves within their definition, which enables recursion. No need for cursors ever again :)

Now for what I think is the coolest thing about CTEs. At the beginning of the post I went through the effort of highlighting their dependence on the subsequent SQL statement so that I could demonstrate this

WITH SimpleCTE(ID, [Name], HierarchyDepth) AS
(
        SELECT
        ID,
        [Name],
        1 AS HierarchyDepth
    FROM
        Category
    WHERE
        Parent IS NULL

    UNION ALL

    SELECT
        c.ID,
        c.[Name],
        SimpleCTE.HierarchyDepth + 1 AS HierarchyDepth
    FROM
        Category AS c
        INNER JOIN SimpleCTE ON c.Parent = SimpleCTE.ID

)
SELECT
    ID,
    [Name],
    HierarchyDepth
FROM
    SimpleCTE
WHERE
    HierarchyDepth < 3
ORDER BY
    HierarchyDepth

ID                   Name                      HierarchyDepth
-------------------- ------------------------- --------------
1                    Software                  1
2                    Hardware                  1
6                    Motherboards              2
7                    CPUs                      2
3                    Games                     2
5                    Business                  2

By specifying a WHERE clause the results only show the categories that are up to second in the hierarchy. What actually happened under the covers is that the recursion stopped at that level rather than completing the recursion and then filtering the results using the WHERE condition. I love this because it’s what sets it apart from using nested select statements and temporary tables to achieve the same result. Imagine having a hierarchy 1,000 levels deep, but you are only interested in the first 10 levels ...

Back from TechEd Barcelona 2007

angelosp — Mon, 12 Nov 2007 14:51:00 +0100

It was a fun week, despite hating myself for eating so much. Thankfully I missed the "free ice cream" session break and I can still fit into some of my clothes.

There were more than enough sessions to choose from and I often found myself not knowing which one to go to first. I decided that I didn't want to attend any "overview" sessions, the kind that just gave a high level view of some feature or technology. I can get that kind of information on MSDN or some code example, I don't need to fly to Barcelona and have some expert present to me a "Hello world" application. With this in mind I went to sessions on the following techonologies

Silverlight (advanced topics; one of the sessions was a big mistake though)
ASP.NET (performance & scalability, hidden gems, asyncronous processing, MVC Framework)
SQL Server Reporting Services (parameters can be used for more than just filtering results)
Security (concepts and principles; wish it went a bit more in depth)
SQL Server 2005 (putting new features in great use, peformance & scalability)
F# (asyncronous programming)
Astoria (exception to the rule of not going to high level sessions)
Visual Studio 2008 & .NET Framework 3.5 (cleared the confusion between v2.0, v3.0, v3.5 and multi-targeting)

In addition to all the sessions and the standard keynote at the beginning of the event, there was a very interesting talk by Pat Helland titled "Movable Objects and Irresistable Forces". It was about how he sees the future of computing in terms of hardware becoming cheaper and more un-reliable (irresistable forces) and how he believes software will have to adapt to cater for this (movable objects).

I'm going to follow this up by a series of posts in each of the topics I think are interesting. In the meantime I'll just finish off by saying that I'm still not convinced by LINQ and I'm not the only one either!

Everyone is so excited about the .Net 3.5 source code being released ..

angelosp — Fri, 05 Oct 2007 09:47:00 +0100

... everyone apart from Frans Bouma and I think he may be right.

His point is this. You are not allowed to modify the code, you are not allowed to re-distribute the code and if you, even without realizing, borrow any ideas from it you could be breaking patents. Why risk it? What real benefit do you get by looking at the source code if you can't at least learn something from it?

I have to agree with him. The only reason I would look at the code would be to see how something tricky or cool was done. I would want to learn from it and use it, in some form, in my code. This is a recipe for disaster and I could be making the company I work for liable for a lawsuit.

Error: 40 - Could not open a connection to SQL Server

angelosp — Thu, 27 Sep 2007 15:12:00 +0100

When you fire up your application and you receive this message, you follow some standard steps and try to find the answer to the following questions

Is my SQL Server up and running?
Can I connect to the box SQL Server is hosted?
Is my connection string correct?
Am I using the correct IP address and instance name?
Is SQL Server accepting the type of connection I want (Named Pipes, TCP/IP, etc)?
Is my firewall blocking either the outgoing connection request or the inbound one?
Is my router not forwarding the connection request to the correct machine and port?

Somewhere between #1 and #7 you will find yourself answering "no", fixing the problem so the answer becomes "yes" and the annoying error message "Error: 40 - Could not open a connection to SQL Server" goes away.

So, what happens when you have answered "yes" to all the questions and the stupid message is still there? In my case it was because I answered "yes" to question #5 without it being true. You see, I assumed that if the SQL Server Configuration Manager says that TCP/UP is enabled (see screenshot below) then my SQL Server is ready to accept TCP/IP connections.

Silly me! When the machine has more than one interface (i.e. IP address that SQL Server can listen to for incoming connections), each one has to be enabled separately.

You will need to enable at least one IP address before SQL Server starts accepts TCP/IP connections. Make sure you enable the one you are trying to connect through :)