Jeremy Simmons: The Blog

What was that format string again? You know, the one for the GUID where you only output the guid, but with no formatting?

using System;
public class GuidTest
{
    public static void Main()
    {
        string[] guidFormats = {"N", "D", "B", "P"};
        Guid g = new Guid();
        Array.ForEach(guidFormats, delegate(string t)
        {
            Console.WriteLine("{0}:{1}", t, g.ToString(t));
        });
        Console.ReadLine();
    }
}

N:00000000000000000000000000000000
D:00000000-0000-0000-0000-000000000000
B:{00000000-0000-0000-0000-000000000000}
P:(00000000-0000-0000-0000-000000000000)

That's right. Now I remember.

Edit: 1/8/2010 - I've forgotten again... Darn.

I should create a mnemonic device to remember this

N = Nothing

D = Dashes

B = Brackets

P = Parenthesis

http://msdn.microsoft.com/en-us/system.guid.tostring.aspx

Sometimes you just need a file with nothing particular in it so you can test a web-page with a <input type="file"/>

Rather than write a snippet of code, or use a utility, you can use the operating system to do this.

On WindowsXP, you can use FSUTIL to do this.

FSUTIL FILE CREATENEWFILE <path> <sizeInBytes>

FSUTIL FILE CREATENEWFILE C:\20mbfile.txt 20971520

It's every so important to read the syntax carefully in computer science. Missing the specifics will get you every time.

Compare these two statements.

DECLARE @sql VARCHAR(8000)
SET @sql = 'SELECT CustomerID FROM Customers'
EXEC @sql

to this

DECLARE @sql VARCHAR(8000)
SET @sql = 'SELECT CustomerID FROM Customers'
EXEC(@sql)

I'm sure you've caught it by now. It's the parenthesis.

Syntax

Execute a stored procedure:

[ [ EXEC [ UTE ] ]
    {
        [ @return_status = ]
            { procedure_name [ ;number ] | @procedure_name_var
    }
    [ [ @parameter = ] { value | @variable [ OUTPUT ] | [ DEFAULT ] ]
        [ ,...n ]
[ WITH RECOMPILE ]

Execute a character string:

EXEC [ UTE ] ( { @string_variable | [ N ] 'tsql_string' } [ + ...n ] )

It's even in bold in the documentation. One would think it might jump out and grab my attention. However sadly, it did not.

I could not find this easily on the web, so I hope this saves someone a search.

Take the following under consideration

string root = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

// We're interested in details, so we'll work with DirectoryInfo instead of Directory and strings
DirectoryInfo rootDirectory = new DirectoryInfo(root);
DirectoryInfo[] subDirectories = rootDirectory.GetDirectories("*", SearchOption.AllDirectories);

DirectoryInfo[] hiddenDirectories =
Array.FindAll<DirectoryInfo>(subDirectories,
delegate(DirectoryInfo d)
{
return (d.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
});

It's wasn't immediately obvious to me how the syntax for Array.FindAll<T> worked. I hope this clears up any confusion in the future.

As a side note. C# 3.0 is the cats meow. This is not 100% equivalent to the above. I think we can all agree we're getting closer to expressing programmers intent.

string start = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

DirectoryInfo root = new DirectoryInfo(start);

var subDirectories = root.GetDirectories("*", SearchOption.AllDirectories).AsQueryable();