.Net Framework

.Net: Controlling Math.Round()

Matt Nield — Wed, 17 Dec 2008 12:41:26 GMT

Having recently been subject to a number of rounding issues in an application, we've had to take a closer look at how rounding works in the .Net framework.

It seams that when using Math.Round(), there is an overload that allows us to specify the type of rounding that is used in the form of the MidpointRounding enumeration.

As the Microsoft documentation will tell you, there are two possible values we can choose from:

ToEven: Round to the nearest even number.
AwayFromZero: Round to the nearest number away from zero.

This proves to be quite interesting when you start thinking about it in a little more detail. I was generally taught at school that you usually round up to the nearest number so that 0.5 becomes 1, -4.5 becomes for and so on. This is not the case in .Net it would seem and I find it a little surprising that it has taken me this long to notice.

If you write a little console application in Visual Studio, you can take a look at how this works:

            Console.WriteLine(

                "Value   Default   Even   FromZero"

);

            for (decimal myValue = -2.0M; myValue < 2.0M; myValue += 0.1M)

                Console.WriteLine(String.Empty.PadLeft(35,'-'));

                Console.WriteLine(

                    "{0}   {1}   {2}   {3}",

                    myValue.ToString("0.0").PadLeft(5),

                    Math.Round(myValue, 0).ToString("00").PadLeft(7),

                    Math.Round(myValue, 0, MidpointRounding.AwayFromZero).ToString("00").PadLeft(4),

                    Math.Round(myValue, 0, MidpointRounding.ToEven).ToString("00").PadLeft(8)

);

The following table give you an idea of how these work for some values.

Value	Round to Even	Round Away from Zero
0.4	0	0
0.5	0	1
1.4	1	1
1.5	2	2

The interesting point is that the default value for Math.Round when not specified is ToEven which is not really what I would have expected. I was also a little intrigued to find that there is not provision of a TowardsZero value. Having a look at Wikipedia, there are numerous methods of rounding and they give a handy list of which languages make which preference. .Net favors what Wikipedia calls 'Round-half-even', which is MidpointRounding.RoundToEven. It's sometimes refereed to as Banker's Rounding.

This clearly is not a massive revelation, but when you start to deal with systems that need to perform calculations and correlate the results of those calculations with other, less-precise systems you should take note of how you will be rounding as checking this out early can prevent headaches later.

BizTalk: Division Functiod Returns Double

Matt Nield — Wed, 01 Oct 2008 14:49:06 GMT

Just a little note here that we noticed testing something (how it had not occurred before, I do not know). We have a function that we were referencing from a referenced assembly that would format values to the slightly odd format being used by the ERP that we were talking too. In most cases it seamed to work OK, but for smaller values it didn't quite product the result we expected.

It turns out that the result of the Division functiod in BizTalk Server 2006 is a double. The mapper being the way it is converts this to a string (assumably using .ToString()). At least this is how it looks when I point ildasm.exe at Microsoft.BizTalk.BaseFunctoids.dll.

Now, rather simply put, I was being a fool and trying to convert this to a decimal and wondering what was going on. I was passing what I though was a value of "0.00002" to my referenced method and expecting it to be formatted properly. When we looked deeper in to the issue, we noticed that the value coming out was in fact "2E-05", which is how a float or a double would represent the value 0.00002.

Quick use of the double.TryParse() fixes this issue and off we trundle.

Worth keeping in mind, and also worth having a look at the base functoids using ildasm.exe when relying on their output.

.Net: Methods with a Variable Number of Arguments

Matt Nield — Fri, 12 Sep 2008 17:02:42 GMT

Summary

Quite often we want to be able to perform the same operation on some information given a differing number of arguments. Typically, you might pass these arguments in as an array, thus avoiding the need to specify the number of arguments. In order to call a function like this, we then need to go ahead and build and array of to pass in our arguments. To me that seems like a little bit of an effort, at each point in my application, I know how many things I want to pass in. So how else can I do this?

Solution

Now, consider the funtion System.String.Format(). In one form, the Format function can take a string and an array of type Objects. A typical call to String.Format will be as follows:

string myString = System.String.Format(
    "Employee #{0} had been with the company since {1}{2}",
    currentEmployee.Number,
    currentEmployee.ContractCommenceDate.ToShortDateString(),
    Environment.NewLine
    );

Notice that our array of objects is represented as a comma separated list. Lets see what happens if we try this and create a simple console application as follows:

using System;
using System.Text;

namespace VariadicFunctions
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(
                Concat(
                    "String 1 ",
                    "String 2 ",
                    "Stirng 3 "
                    )
                );
        }

        /// <summary>
        /// Glue a lots of strings together in to the mother of all strings.
        /// </summary>
        /// <param name="myStrings">A collection of obedient strings</param>
        /// <returns>The mother of all strings</returns>
        public static String Concat(string[] myStrings)
        {
            StringBuilder sBuild = new StringBuilder();

            foreach (String str in myStrings)
            {
                sBuild.Append(str);
            }

            return sBuild.ToString();
        }
    }
}

When we compile, we get an error telling us "No overload for method 'Concat' takes '3' arguments". That makes sense, the method is looking for a string array, not a load of separate strings. What we need to do is turn this in to what is know as a Variadic Function.

A variadic functions is a function that takes an variable number of arguments. Essentially, to turn our function 'Concat' in to a variadic function we just need to use the params keyword. What this keyword does is, in simple-speak, allows us to enter our additional arguments in a comma separated list. Simply adding this keyword in will then allow us to comma-separate our arguments:

using System;
using System.Text;

namespace VariadicFunctions
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(
                Concat(
                    "String 1 ",
                    "String 2 ",
                    "Stirng 3 "
                    )
                );
        }

        /// <summary>
        /// Glue a lots of strings together in to the mother of all strings.
        /// </summary>
        /// <param name="myStrings">A collection of obedient strings</param>
        /// <returns>The mother of all strings</returns>
        public static String Concat(params string[] myStrings)
        {
            StringBuilder sBuild = new StringBuilder();

            foreach (String str in myStrings)
            {
                sBuild.Append(str);
            }

            return sBuild.ToString();
        }
    }
}

And there we go, no build errors, we can add as many stings as we like without issue.

References:

Variadic Functions on Wikipedia: http://en.wikipedia.org/wiki/Varargs
Params Keyword on MSDN: http://msdn.microsoft.com/en-gb/library/w5zay9db.aspx

Keywords:

Variadic, params, arguments array, variable arguments, variable parameters, parameters array

BizTalk: Unit Testing BizTalk Maps in Visual Studio

Matt Nield — Thu, 10 Jul 2008 15:27:45 GMT

If you're using BizTalk Server maps, it is about 99.999% likely that you are using logic in them. Testing this functionality in Visual Studio can be tedious as the only way to change the test document is in the properties of the map. So if you have quite a few scenarios to test, this method sucks. BizTalk Server 2000 and 2002 allowed you to select the test document at runtime, which was nice I suppose but it still meant that you had to do it manually all the time.

With the exception of either figuring out how to use BizUnit and actually deploying your solution, there are not too many ways to quickly test multiple scenarios of documents in your maps. I wanted to create a series of tests for a project that I was working on so that I could very quickly test the outcome of my BizTalk Server maps and essentially 'tick some boxes' before moving in to system testing. There is nothing worse than a BizTalk Server deploy just to find out you've forgotten something that is key in your map.

Using BizTalk Server Maps in Code

I use Test Projects in Visual Studio to do a majority of my unit tests have recently stopped using NUnit. What I wanted was a nice way to simply perform multiple BizTalk Server map tests at the click of a button. Saving me a great deal of time and helping me to ensure my deployments contain maps that fulfil the project requirements.

I'll not go in to how to create the actual test projects, the purpose of this article is to call a BizTalk Server map in code so that we can examine the output.

In order to reference BizTalk Server maps, you must first add a reference to Microsoft.XLANGs.BaseTypes which can be found in C:\Program Files\Microsoft BizTalk Server 2006\Microsoft.XLANGs.BaseTypes.dll or wherever you ended up installing BizTalk Server. Once you have this, it's actually pretty simple (although it took me a while to figure everything out and I was trying to do stuff manually that was already done for me).

Below is the code I used to execute a map.

// Create an instance of the map from the BizTalk Server project
MyBizTalkProjects.Schemas.MapProduct map = new MyBizTalkProjects.Schemas.MapProduct();

// Create an XPath document based on the XML file that is our source
System.Xml.XPath.XPathDocument source;

// Open the XML document from the file system and load it in to the XPath document
using (
    System.IO.StreamReader sRead = new StreamReader(
        @"D:\BraitrimDotNet\BizTalk\Schemas TestProject\EBizDocuments\DespatchConfirmation.xml"
        )
    )
{
    source = new System.Xml.XPath.XPathDocument(sRead);
}

// This took a while to figure out.  Essentially the map is a fully declared XslTransform.  as such, the
// extension objects (i.e. functiod references) are already referenced and so we can use this reference
// rather than trying to build it ourselves.
System.Xml.Xsl.XsltArgumentList args = map.TransformArgs;

// Set the XmlReader to the transorm.
System.Xml.XmlReader xReader = map.Transform.Transform(source, args);

// Perform the transform and load it in to an XmlDocument for examination
System.Xml.XmlDocument result = new System.Xml.XmlDocument(xReader.NameTable);
result.Load(xReader);

Once I have the XmlDocument, I can simply use XPath queries to check values in the XML match my anticipated output.

In Visual Studio, I essentially create a test method for piece of map logic that I want to test. That way, when I run my tests from the Test View window, I can quickly see what has worked and what has not.

.Net: Adding GacUtil.exe to the 'Send To' Menu

Matt Nield — Wed, 09 Jul 2008 09:12:23 GMT

I tend to spend a lot of time adding assemblies to the GAC (Global Assembly Cache) in order to run unit tests or work with BizTalk Server assemblies. Usually, I'll do this using the Visual Studio command prompt or the .Net configuration tool. I wanted to find a marginally quicker way to add assemblies to the GAC so I started to look at the 'Send To' menu.

In order to add shortcuts to your 'Send To', simply navigate to the following folder:

C:\Documents and Settings\<User Name>\SendTo

In here you can create simple shortcuts to applications. So for example you can add a 'Send To Notepad' shortcut. I'm not going to go in to all of the detail of creating a shortcut here though.

What I wanted to do was add shortcut to gacutil.exe. The first thing to think about is where Microsoft decided to put the thing in your particular version of .Net. To help you here, I created a little list of places that you are likely to find gacutil.exe for different versions of the framework

Framework Version	Possible Locations
1.0	C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705
1.1	C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322
2.0	C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\bin\
3.0	C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin (not too sure about this one)
3.5	C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin

Once you've located your gacutil.exe, create a shortcut to it in the SendTo folder mentioned above. In order to get it to work, simply modify the target of the shortcut so that there is a '/i' at the end of the target (outside of the quotes) as in the following diagram:

That should do it, from now on you should get the following in your context menu:

BizTalk: Type 'System.Xml.XmlDocument' in Assembly 'System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' is not marked as serializable.

Matt Nield — Tue, 27 May 2008 10:44:43 GMT

I ran in to this problem recently while developing a solution for a client. For me it took a little while to figure out what was happening and the error was reported to be coming from a send shape that sent a message of type System.Xml.XmlDocument.

While this is the correct place for the error to be raised, it was not strictly related to them message that I was trying to send.

The actual cause of the problem is that I have a class that is used to return information back from a series of helper methods in a library that I have built. The class has 3 public properties:

Result: An inumeration indicatign the level of success
Document: when successful, this is an XML document otherwise, it is null.
Exception: this is null if the call was successful, otherwise it contains all relevant information to describe the failure.

Document is a System.Xml.XmlDocument and it is this that is causing the error. Essentially, BizTalk Server seems to be trying to serialize this class, either for dehydration, analyst reporting or some other reason. All we need to do to avoid this error is simply mark the property as nonserializable, I.e:

/// <summary>
/// Contains the result of a receipt processing attempt.
/// </summary>
[Serializable()]
public class ReceiptResult
{
    private ReceiptSuccessResult _result;
    [NonSerialized()]
    private XmlDocument _document;
    private ReceiptException _exception;

    /// <summary>
    /// Gets the overall result of the validation attempt.
    /// </summary>
    public ReceiptSuccessResult Result
    {
        get { return this._result; }
    }

    /// <summary>
    /// Gets any XML document that may have been returned from the validation attempt.
    /// </summary>
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes", MessageId = "System.Xml.XmlNode")]
    public XmlDocument Document
    {
        get { return this._document; }
    }

    /// <summary>
    /// Gets any exception that was returned from the validation attempt.
    /// </summary>
    public ReceiptException Exception
    {
        get { return this._exception; }
    }

    public ReceiptResult(ReceiptSuccessResult result)
    {
        this._result = result;
    }

    public ReceiptResult(ReceiptSuccessResult result, XmlDocument document)
    {
        this._result = result;
        this._document = document;
    }

    public ReceiptResult(ReceiptSuccessResult result, ReceiptException exception)
    {
        this._result = result;
        this._exception = exception;
    }
}

After that (for me at least) the error goes away.

ASP.Net: Performance and Scaling Tips from MSDN

Matt Nield — Thu, 15 May 2008 12:20:31 GMT

I found these two great articles on MSDN about performance and scaling of ASP.Net applications. They're well worth a read in my opinion.

ASP.Net Membership Provider

Matt Nield — Thu, 10 Apr 2008 08:09:24 GMT

Overview

I'm making a concerted effort to give myself a more understanding of ASP.Net. One of the things I recall from classic ASP and my early forays in to ASP.Net was creating authentication for site. Generally we created a standard set of functions that we could reuse, but the generally always ended up being 'tweaked' from project to project. Along with ASP.Net 2.0 Microsoft delivered provider models. These models can be used for site membership and roles and so looking at the membership role immediately came to mind as being something interesting to look at.

Implementation

I'm just going to create a simple ASP.Net web application and add some authentication to it. In essence, this is a simple as dropping on a Login and a Create User Wizard web user control on to a page or two in to the project. This will automatically create a SQL Express database to store our user information. All of the Login controls will pretty much work using this approach. Me being me however, I don't want to use the MS SQL Express database as it is. Yes, I will be using SQL Express, but I want to use my tables and store the information how I want. To the end, I need to write my own membership provider to provide the kind of information that I need to e stored and retrieved.

So, the fist thing I do is add a class to my web project called MySqlMembershipProvider in the App_Code folder. From reading various posts around the interned, all I need to do is make this class inherit from the System.Web.Security.MembershipProvider class and all of the stubbed out derived methods will be created for me. Nah, not really - I'm using C# so I have to right click on the inherited class and select 'Implement Abstract Class' to tell it to go do this for me. VB.Net (*spit) does do this automatically however if you're using that.

I'm going to implement two methods on this test application:

CreateUser(): This will allow me to add new users to the database.
ValidateUser(): Given a couple of details (namely user name and password) this will tell me if the user exists or not.

These are enough to be able to log on to our site and create new users and that is all that I want to do for the moment.

So, first of all, we'll create a database. I'm using a SQL Express, but you really can use anything you like here; MySQL, an XML file or perhaps a link to Active Directory. The choice is yours, but the SQL example is easier because pretty much everyone gets it. In my database I'm going to create a table called 'User' as follows in my database:

Name	Type	Key
Username	NVarChar(50)	Primary Key
Password	NVarChar(50)	No
EmailAddress	NVarChar(50)	No
PasswordQuestion	NVarChar(50)	No
PasswordAnswer	NVarChar(50)	No

Once I've created this, I can begin development. We'll carry on with the MySqlMembershipProvider class.

I'm going to override the Initialize class and add some functionality to read some settings from the web.config file. I'm going to store one property:

connectionString will store the connection string to my database. In my case, this connection string is as follows:
Data Source=.\SQLEXPRESS;AttachDbFilename=F:\SQLMembershipProvider\App_Data\SQLMemberShipProvider.mdf;Integrated Security=True;User Instance=True

Create this as private variable in the class to store this and then to the MySqlMembershipProvider add the following code:

/// <summary>
/// Set up the initial properties that we need when the provider is first loaded
/// </summary>
/// <param name="name">The full name of the provider.</param>
/// <param name="config">Contents of the web.config for the provider</param>
public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config)
{
    connectionString = config["connectionString"];
    base.Initialize(name, config);
}

The above code loads the connection string so that we can use it later. Not that Initialize is not created when we implemented that abstract class, it's one that we need to do ourselves.

As I touched on earlier, we then need to implement 'CreateUser' and 'ValidateUser' so that we will be able to logon and create new users on the site. The two methods used for this have already been created so we will need to replace the line in the stubbed method with some real code to insert to the database and also retrieve users form the database. So, in my example, modify those methods to look as follows:

/// <summary>
/// Creates a user in the provider database and returne an instance of that user.
/// </summary>
/// <param name="username">Provided username</param>
/// <param name="password">Provided password</param>
/// <param name="email">Provided email address</param>
/// <param name="passwordQuestion">Provided password question</param>
/// <param name="passwordAnswer">Provided password answer</param>
/// <param name="isApproved">Boolean indicateing if the user is allowed to logon.</param>
/// <param name="providerUserKey">The user identifier for the user that should be stored in the membership database</param>
/// <param name="status">The status indicated success of user created or reason for failure.</param>
/// <returns>A MembershipUser object for the newly created user</returns>
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
    SqlConnection sqlConnection = new SqlConnection(this.connectionString);
    try
    {
        sqlConnection.Open();
        SqlCommand sqlCommand = new SqlCommand();
        sqlCommand.Connection = sqlConnection;
        sqlCommand.CommandText = "INSERT INTO User VALUES (@username, @password, @email, @passwordQuestion, @passwordAnswer )";
        sqlCommand.CommandType = CommandType.Text;
        sqlCommand.Parameters.AddWithValue("@username", username);
        sqlCommand.Parameters.AddWithValue("@password", password);
        sqlCommand.Parameters.AddWithValue("@email", email);
        sqlCommand.Parameters.AddWithValue("@passwordQuestion", passwordQuestion);
        sqlCommand.Parameters.AddWithValue("@passwordAnswer", passwordAnswer);

        int result = sqlCommand.ExecuteNonQuery();

        sqlCommand = null;
        sqlConnection.Close();

        status = MembershipCreateStatus.Success;
        return new MembershipUser(
            "SQLMembershipProvider.MySQLMembershipProvider",
            username,
            null,
            email,
            passwordQuestion,
            string.Empty,
            true,
            false,
            DateTime.Now,
            DateTime.MinValue,
            DateTime.MinValue,
            DateTime.MinValue,
            DateTime.MinValue
            );
    }
    catch (Exception ex)
    {
        System.Diagnostics.Trace.Write("CreateUserFailed: " + ex.Message);
        // HACK: I'm just going to say we failed here.  We can however be more creative and say _why_
        status = MembershipCreateStatus.UserRejected;
        return null;               
    }
}

/// <summary>
/// Check to see if the username and password combination exists in the user table.
/// </summary>
/// <param name="username">Supplied Username</param>
/// <param name="password">Supplied Password</param>
/// <returns>Boolean indicating match success</returns>
public override bool ValidateUser(string username, string password)
{
    // Connect to the providers DB
    SqlConnection sqlConnection = new SqlConnection(this.connectionString);
    try
    {
        sqlConnection.Open();
        SqlCommand sqlCommand = new SqlCommand();
        sqlCommand.Connection = sqlConnection;
        // I spit at myself for hard-coded SQL, but this is only a demo :)
        sqlCommand.CommandText = "Select Username, Password, Email, PasswordQuestion, PasswordAnswer From User WHERE username=@username AND password=@password";
        sqlCommand.CommandType = CommandType.Text;

        sqlCommand.Parameters.AddWithValue("@username", username);
        sqlCommand.Parameters.AddWithValue("@password", password);

        SqlDataReader reader = sqlCommand.ExecuteReader();

        // If there are rows, then the login succeeds.  Due to the primary key, there should only ever be a maximum of one row anyway
        return reader.HasRows;

        sqlConnection.Close();
    }
    catch 
    {
        // HACK: Should really log any technical errors rather than just ignoring them in this way
        return false;
    }
}

This is almost everything fro this class, but I do want the user to be able to enter a secrete password question and answer, There is a public property for this that at the moment throws and exception as we have not implemented it. SO we'll just make this return true so that the web controls know what to do for now. WE can put this in to the web.config file, but for this example I'm not going to. Just modify the RequiresQuestionAndAnswer to return true.

We need to modify the web.config file to tell it which MembershipProvider to use. So, in the web.config, change the authentication mode to 'Forms' and add the membership section as demonstrated below:

<authentication mode="Forms" />
<membership defaultProvider="SQLMembershipProvider.MySQLMembershipProvider" >
    <providers>
        <add name="SQLMembershipProvider.MySQLMembershipProvider"
pe="SQLMembershipProvider.MySQLMembershipProvider"
nnectionString="Data Source=.\SQLEXPRESS;AttachDbFilename=F:\SQLMembershipProvider\App_Data\SQLMemberShipProvider.mdf;Integrated Security=True;User Instance=True" />
    </providers>
</membership>

Right, that is the trick bit. Next we simply need to create two pages in out web application; one page to login and one page to be the homepage. We'll call these (wait for it) Default.aspx and Login.aspx.

So, to start with we'll create Login.aspx. In design mode, drop a Login control on to the page. Right, that's that page done.

Now lets create Default.aspx. Again, switch to design view so we can drag some controls on. The first two controls are the Create User Wizard and the Login View.

Drag a CreateUserWizard control on to the page. We need to change one property of this control, and the is ContinueDestinationPageUrl. Change this property to Login.aspx so that when a user is created they will then be asked to login.

Next, drag a LoginView control on to the page. This control allows us to see different things depending on who we are. In the tasks tool-tip, select the AnonymousTemplate view. In to the LoginView, drag a LoginStatus control. This gives a simple login button for unauthenticated users.

Next, switch to the LoggedInTemplate view of the LoginView control. In here we will also add a LoginStatus control. We will also however add a LoginName control so that we can tell logged in users who they are. Type some guff around thsi so that you end up with something like the following in your LoginView:

You are logged in as [UserName].

That pretty much should be it. You should just be able to hit F5 and run the project.

LINQ: Error 19 Could not find an implementation of the query pattern for source type

Matt Nield — Fri, 25 Jan 2008 10:12:48 GMT

Overview

I reckon that I have probably seen the same LINQ demo as just about everyone else in the world. You know, the one where you get a list of all of the processes running on the server and print them out to the console as follows:

var processes = from activeProcesses in Process.GetProcesses() 
                select new { Name = activeProcesses.ProcessName, ProcessId = activeProcesses.Id };

foreach (var row in processes) Console.WriteLine(row.ToString());

Console.ReadLine();

Well, I tired to use the same principle to iterate through a custom collection for an idea I was trying out and I got a heavily descriptive error of:

"Error 19 Could not find an implementation of the query pattern for source type"

So what does that mean?

Solution

It can actually mean a couple of things depending on the full error message. The two main causes that I have noticed are:

Your source is not enumerable!!
LINQ doesn't have a clue what your source is.

The first issue is fairly easily addressed, make sure you use enumerable types. It turns out that in the example I was trying to make work, I'd used the wrong object as the source which was why I got the error in the first place.

Once I had changed to the correct object, I still had the error. The difference was that the error message now also included the following

"Consider explicitly specifying the type of the range variable"

Interesting I thought, why on earth would that be? The code I had originally was as follows:

var pollingDirectories = from directory in serviceConfigSection.PollingDirectoires 
                select new { DirectoryPath = directory.Path, FileType = directory.FileType };

foreach (var row in pollingDirectories ) Console.WriteLine(row.ToString());

Console.ReadLine();

What I need to to was to tell LINQ the type of source explicitly so that it would know what to do with it. So I needed to make my code look as follows:

var pollingDirectories = from DirectoryElement directory in serviceConfigSection.PollingDirectoires 
                select new { DirectoryPath = directory.Path, FileType = directory.FileType };

foreach (var row in pollingDirectories ) Console.WriteLine(row.ToString());

Console.ReadLine();

After that - everything seems to work just fine.

I guess in some cases, LINQ just needs to be given a little more information about what it is doing.

References

Versions

Microsoft .Net Framework 3.5

Metadata

Categories: .Net Framework 3.5, Visual Studio 2008, Orcas, LINQ
Additional Keywords: Orcas, LINQ, Error 19, Enumerable, IEnumerable

Formatting Numbers using IFormatProvider and ToString

Matt Nield — Thu, 10 Jan 2008 16:50:53 GMT

As I've had a number of people mention to me that they don't quite know how to use a class that implements the IFormatProvider interface. In most case that come to my attention, we are specifically interested in date formats and number formats.

Below is the code for a simple console application in .Net 2.0 that will use the NumberFormatInfo class to format the display of a numeric value. I've set up two instances of the NumberFormatInfo class, one for French formatting and one for British English formatting. The CultureInfo class from the Globalization namespace has been used to load up the culture specific information that I need for this example.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;

namespace IFormatProvider
{
    class Program
    {
        static void Main(string[] args)
        {
            double testValue = 10.234;

            NumberFormatInfo britishFormatter = CultureInfo.CreateSpecificCulture("en-GB").NumberFormat;
            NumberFormatInfo frenchFormatter = CultureInfo.CreateSpecificCulture("fr-FR").NumberFormat;

            Console.WriteLine("In fr-FR, our value is {0}", testValue.ToString(frenchFormatter));
            Console.WriteLine("In en-GB, our value is {0}", testValue.ToString(britishFormatter));
            Console.ReadLine();
        }
    }
}

When you run the above code in Visual Studio, you will see the following output:

In fr-FR, our value is 10,234
In en-GB, our value is 10.234

This then got me thinking. As I have now told the application what I want to do, I assume tha by default the ToString method on must have some kind of default based on the application thread. I also know that the application thread has two sets of culture information; the UI culture and the system culture. That led to the question; which is the default?

So I went ahead and wrote the following to see which culture information is the default.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Threading;

namespace IFormatProvider
{
    class Program
    {
        static void Main(string[] args)
        {
            double testValue = 10.234;

            Console.WriteLine(
                "Default Culture information: UI [{0}] - SYSTEM [{1}]",
                Thread.CurrentThread.CurrentUICulture.Name,
                Thread.CurrentThread.CurrentCulture.Name
                );
            Console.WriteLine(
                "Our Value: {0}",
                testValue.ToString()
                );

            Console.WriteLine("> Change CurrentUICulture to French...");
            Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
            Console.WriteLine(
                "> Our Value: {0}",
                testValue.ToString()
                );

            Console.WriteLine("Change CurrentCulture to French...");
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
            Console.WriteLine(
                "> Our Value: {0}",
                testValue.ToString()
                );

            Console.ReadLine();
        }
    }
}

Interestingly, the output is as follows:

Our Value: 10.234
> Change CurrentUICulture to French...
> Our Value: 10.234
> Change CurrentCulture to French...
> Our Value: 10,234

So, for the sake of interest; it looks like CurrentCulture is used as the default.

References