19 May 2010

.NET 4 Baby Steps: Part XIII - Tiny steps

07042010191 Note: This post is part of a series and you can find the rest of the parts in the series index.

There is a bunch of tiny additions in .NET 4 which I have not covered yet, this post provides a quick hit list of some of the new and improved features:

New

  • new StringBuilder.Clear: Quick method to clear a string builder.
  • new StopWatch.Reset: Quick method to reset a stop watch timer.
  • new IntPtr & UIntPtr: Both have had two new methods added, one for addition and one for subtraction.
  • new Thread.Yield: Allows you to yield execution to another thread that is ready to run on the current processor.
  • new System.Guid: Has got two new methods, TryParse and TryParseExact to allow for testing of the parsing.
  • new Microsoft.Win32.RegistryView: This allows you to request 64bit or 32bit views of the registry.
  • new Environment: Now contains two properties to identify 64bit scenarios:
    • Is64BitOperatingSystem: To identify if the OS is 64bit.
    • Is64BitProcess: To identify if the process is 64bit.
  • new System.Net.Mail.SmtpClient: Support for SSL

Improved

  • better Path.Combine: A new method overload to allow you to combine file paths.
  • better Compression.DeflateStream & Compression.GZipSteam: They have been improved so that they so no try to compress already compressed data.
  • better Compression.DeflateStream & Compression.GZipSteam: The 4Gb size limit has been removed.
  • better Monitor.Enter: A new overload has been added which allows you to pass in a reference boolean which returns true of the monitor was successfully entered.
  • better Microsoft.Win32.RegistryOptions: Now includes an option to specify a volatile key which is removed when the system restarts.
  • better Registry keys are no longer limited to 255 characters.
  • better System.Net.Mail.MaiMessage: Support for new headers
    • HeadersEncoding: Sets the type of text encoding used in the mail header.
    • ReplyToList: Sets the list of addresses to use when replying to a mail. This replaces ReplyTo which only supported one email address.
  • better System.Net.NetworkCredential: To improve security passwords can now be stored in a SecureString.
  • better ASP.NET Hashing: The default value has been changed from SHA1 to SHA256.
  • better ASP.NET Output caching: Previously setting the output cache to ServerAndClient also required calling SetOmitVaryStar to ensure it would be cached on the client. From .NET 4, calling of SetOmitVaryStar is no longer needed.
  • better TimeZoneInfo.Local & DateTime.Now: Both of these follow the OS daylight savings settings rather than using the .NET Framework settings.
  • better When running on Windows 7, locale info will be retrieved from the OS rather than being stored in the framework.
  • better Support for all 1400 characters of Unicode 5.1.
  • better ServiceInstaller.DelayedAutoStart: If you on a more modern OS (Vista, Win 7 etc…) then you can services can start as Automatic Delayed. This means they start, but after system boot so that the user gets in quickly. This is now possible for your .NET apps using the DelayedAutoStart property.
18 May 2010

.NET 4 Baby Steps: Part XII - Numbers

22032010170 Note: This post is part of a series and you can find the rest of the parts in the series index.

A new namespace has arrived in .NET 4 for those who spend a lot of time with numbers, System.Numerics which has two classes: BigInteger and Complex – and they are exactly what they say they are. BigInteger is for big integers and Complex is complicated ;)

BigInteger

BigInteger is a class, not a type (like float), which allows you to have an integer with no theoretical upper and lower limits! Why is that cool? think about Int64 which can do up to: 9,223,372,036,854,775,807. If you have an Int64 which has that massive value, and you add one to it, the Int64 it overflows and becomes -9,223,372,036,854,775,806. That is not possible with BigInt since it has no upper limit!

Being a class means it has methods and properties you can use too, for example some of the properties

  • IsZero: Tells you if it equals zero.
  • IsEven: Tells you if it is an even number.

An example of using it:

BigInteger firstBigInt = new BigInteger(Int64.MaxValue);
BigInteger secondBigInt = new BigInteger(Int64.MaxValue);

Console.WriteLine("First BigInt is even? {0}", firstBigInt.IsEven);
Console.WriteLine("First BigInt = 1? {0}", firstBigInt.IsOne);
Console.WriteLine("First BigInt is power of twp? {0}", firstBigInt.IsPowerOfTwo);
Console.WriteLine("First BigInt = 0? {0}", firstBigInt.IsZero);
Console.WriteLine("First BigInt is positive (1), zero (0), or negative (-1)? {0}", firstBigInt.Sign);
Console.WriteLine("{0} multipled by {0} is {1}", Int64.MaxValue, BigInteger.Multiply(firstBigInt, secondBigInt));

You can also use the standard operators (-, +, * etc…) with it.

This gives the following output (look at the size of the number from the multiplication!):

image 

BigRational

What if you want to work with rational numbers with no limits, rather than integers? Then you can use the BigRational class the BCL team has made available at http://bcl.codeplex.com/

Complex

A complex number is a number that comprises a real number part and an imaginary number part. A complex number z is usually written in the form z = x + yi, where x and y are real numbers, and i is the imaginary unit that has the property i2 = -1.

That snippet is the first line from the documentation on System.Numeric.Complex and unfortunately I am not smart enough to know what they are talking about. So who should understand this?

  • Electrical engineers: Using Complex they can do the following: Resistance(R) and Reactance(X) to calculate the impedance Z.
  • Mathematicians: Vector Calculus as well as Graphs.
  • People using positional (mapping) info: X, Y coordinates on a  map or 2d plane.

For an example I will just wimp out and show you what the MSDN documentation has:

// Create a complex number by calling its class constructor.
Complex c1 = new Complex(12, 6);
Console.WriteLine(c1);

// Assign a Double to a complex number.
Complex c2 = 3.14;
Console.WriteLine(c2);

// Cast a Decimal to a complex number.
Complex c3 = (Complex)12.3m;
Console.WriteLine(c3);

// Assign the return value of a method to a Complex variable.
Complex c4 = Complex.Pow(Complex.One, -1);
Console.WriteLine(c4);

// Assign the value returned by an operator to a Complex variable.
Complex c5 = Complex.One + Complex.One;
Console.WriteLine(c5);

// Instantiate a complex number from its polar coordinates.
Complex c6 = Complex.FromPolarCoordinates(10, .524);
Console.WriteLine(c6);

That produces:

image

Some info on complex is from: http://www.dotnetspider.com/resources/36681-Examples-On-Complex-Class-C-New-Feature.aspx

17 May 2010

.NET 4 Baby Steps - Part XI: Special folders

15052010218 Note: This post is part of a series and you can find the rest of the parts in the series index.

Environment.SpecialFolder

If you are building an application which takes advantage of special folders in Windows (special folders are folders like My Documents), you will be happy to know that .NET 4 has expanded the number of special folders it support, by adding 25 new options to the Environment.SpecialFolder enum.

The new options are:

  1. AdminTools
  2. CDBurning
  3. CommonAdminTools
  4. CommonDesktopDirectory
  5. CommonDocuments
  6. CommonMusic
  7. CommonOemLinks
  8. CommonPictures
  9. CommonProgramFilesX86
  10. CommonPrograms
  11. CommonStartMenu
  12. CommonStartup
  13. CommonTemplates
  14. CommonVideos
  15. Fonts
  16. LocalizedResources
  17. MyVideos
  18. NetworkShortcuts
  19. PrinterShortcuts
  20. ProgramFilesX86
  21. Resources
  22. SystemX86
  23. Templates
  24. UserProfile
  25. Windows

Usage is:

Console.WriteLine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos));

GetFolderPath

The GetFolderPath method has also gotten an update with a new overload which takes a second enum, SpecialFolderOption. This has three values

  • None: Returns the path, but does not verify whether the path exists. If the folder is located on a network, specifying this option can reduce lag time.
  • Create: Verifies the folder path. If the folder does not exist, an empty string is returned. This is the default behavior.
  • DoNotVerify: Forces the folder to be created if it does not already exist.

Super fast network option:

Console.WriteLine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos, Environment.SpecialFolderOption.None));
14 May 2010

DevDays Durban Slides and Bits

I had a great time in Durban this week presenting at the DevDays event. I was a bit nervous for my first keynote but calmed down once I was up there. I was much less nervous for the sessions and they turned out to be great fun.

Knowing is half the battle

As part of my prep I did fully script the demos and those scripts are included in hidden slides in the slide shows – so if you are looking to recreate the demos please download the slides and have a look.

For both my sessions I made use of the excellent (but I’m biased) Rule 18 tool. So if you looking for the actual code, which I referred to in my scripts with Rule 18 key presses, you should really download that too.

All the demos were done using Visual Studio 2010.

What’s new in ASP.NET 4?

What’s new in .NET 4?

14 May 2010

.NET 4 Baby Steps - Part X: Location, Location, Location

Note: This post is part of a series and you can find the rest of the parts in the series index.

This is seriously some of the coolest stuff in .NET 4: System.Device.Location which gives you access to the Windows 7 sensor platform to build location aware applications. The two important classes to know are:

  • GeoCoordinateWatcher: Think of this as your GPS device. It gives you time and latitude and longitude.
  • CivicAddressResolver: This translates latitudes and longitude into addresses!

Usage

Usage of it is very easy. First we create a resolver and gps and then we tell the GPS to start. We assign an event to alert us when the position has changed and when we done we tell the GPS to stop.

static System.Device.Location.CivicAddressResolver resolver = new System.Device.Location.CivicAddressResolver();
static System.Device.Location.GeoCoordinateWatcher gps;

static void Main(string[] args)
{
    Console.Clear();
    Console.WriteLine("Press any key to quit");

    using (gps = new System.Device.Location.GeoCoordinateWatcher())
    {
        gps.PositionChanged += new EventHandler<System.Device.Location.GeoPositionChangedEventArgs<System.Device.Location.GeoCoordinate>>(gps_PositionChanged);
        
        gps.Start();                

        Console.ReadKey();

        gps.Stop();
    }
}

When the GPS position changes we write it to the screen as follows:

static void gps_PositionChanged(object sender, System.Device.Location.GeoPositionChangedEventArgs<System.Device.Location.GeoCoordinate> e)
{
    Console.Clear();
    Console.WriteLine("Last updated at: {0}", DateTime.Now);
    Console.WriteLine("Your location: {0}", e.Position.Location);
    Console.WriteLine("I think that is: {0}", NiceAddress(e.Position.Location));
    Console.WriteLine("Press any key to quit");
}

How do we get our address and display it nicely?

private static object NiceAddress(System.Device.Location.GeoCoordinate geoCoordinate)
{
    System.Device.Location.CivicAddress address = resolver.ResolveAddress(geoCoordinate);
    if (address.IsUnknown)
    {
        return "Unknown";
    }

    return string.Join("\n", address.FloorLevel, address.Building, address.AddressLine1, address.AddressLine2, address.City, address.StateProvince, address.CountryRegion, address.PostalCode);
}

And all this code produces the following:

image

Distances?

The GeoCoordinate class has a brilliant method called GetDistanceTo which returns the distance, in meters (Metric system FTW) between it and another GeoCoordinate. So for me to find the distance to the Lions Rugby Team home stadium I just do:

static void gps_PositionChanged(object sender, System.Device.Location.GeoPositionChangedEventArgs<System.Device.Location.GeoCoordinate> e)
{
    Console.Clear();
    Console.WriteLine("Last updated at: {0}", DateTime.Now);
    System.Device.Location.GeoCoordinate ellisPark = new System.Device.Location.GeoCoordinate(-26.1978417421848, 28.060884475708 );
    Console.WriteLine("It is {0}km to Ellis Park", e.Position.Location.GetDistanceTo(ellisPark) / 1000);
    Console.WriteLine("Press any key to quit");
}

Which gives:

image

Accuracy?

The accuracy can be controlled in settings, but a lot of it is up to your GPS receiver device. Unfortunately I do not have a proper hardware based GPS device, so I have used the excellent free software based Geosense for Windows, which you can see is accurate enough for most scenarios.

No sensor?

If you are on a version of Windows prior to 7, then the status of the GPS sensor will be set to Disabled.

If you are on Windows 7 without a GPS sensor then when you run it, you will be prompted for your default location information which Windows can try and use to find you.

image

Mobile?

As a bonus to using this, it is similar as the geolocation system in the new Windows Phone 7 platform! You can find out about geolocation in Windows Mobile 7 in Rudi’s blog post.

13 May 2010

.NET 4 Baby Steps: Part IX - Stream

Note: This post is part of a series and you can find the rest of the parts in the series index.

Streams are something I try to avoid, it feels to me like I am getting down and dirty when I use them – but maybe that is just flash backs to working in Delphi :) They are very useful, but they can be clunky especially when you need to get the content into another stream.

The key example of coping a steam is when you write your own file copy method (and which programmer hasn’t):

using (FileStream sourceFile = new FileStream("test.xml", FileMode.Open))
{
    using (FileStream destinationFile = new FileStream("target.xml", FileMode.Create))
    {
        byte[] buffer = new byte[4096];
        int read;
        while ((read = sourceFile.Read(buffer, 0, buffer.Length)) != 0)
        {
            destinationFile.Write(buffer, 0, read);
        }
    }
}

The whole buffer/read/write pattern is just ugly.

Now with .NET 4, we can use the new CopyTo method to fix this up:

using (FileStream sourceFile = new FileStream("test.xml", FileMode.Open))
{
    using (FileStream destinationFile = new FileStream("target.xml", FileMode.Create))
    {
        sourceFile.CopyTo(destinationFile);
    }
}

Ah, much better!

12 May 2010

.NET 4 Baby Steps: Part VIII - Enumerate Directories and Files

 cael Note: This post is part of a series and you can find the rest of the parts in the series index.

.NET 4 has seven (!!) new methods for enumeration of directories, files and contents of files. What makes these stand apart from what we have had before, is these return IEnumerable<T> rather than arrays.

Why is it better to get IEnumerable<T> over an array? Rather than getting all the data into one structure first, the array, and returning a massive lump of data. With IEnumerable<T> it returns it one item at a time, as it enumerates that item. If this doesn’t make sense, see the example below.

Example

Old way

So in this example I use the old method:

DirectoryInfo root = new DirectoryInfo(@"c:\");

var collection = from f in root.GetFiles("*", SearchOption.AllDirectories)
                 select f;

foreach (var item in collection)
{
    Console.WriteLine(item);
}

However due to some permissions it will fail with an exception. Note where the exception is, it is where we are asking for the files and the the console output at this point is empty because it hasn’t finished loading all the data into the array.

image

New Way

Now we change it to the new method:

DirectoryInfo root = new DirectoryInfo(@"c:\");

var collection = from f in root.EnumerateFiles("*", SearchOption.AllDirectories)
                 select f;

foreach (var item in collection)
{
    Console.WriteLine(item);
}
This time see how the exception occurred during the iteration of the items and note how the output contains some files now, because it has processed those already.

image

This is a major advantage of the new IEnumerable<T> versions, because now we do not need to wait for all items to be found first and that means it is easier to do high performance code and threading.

What are the new methods?

The seven methods are:

  • Directory.EnumerateDirectories
    • This returns IEnumerable<string> of the folder names.
  • DirectoryInfo.EnumerateDirectories
    • This returns IEnumerable<DirectoryInfo>.
  • Directory.EnumerateFiles
    • This returns IEnumerable<string> of the files fullname.
  • DirectoryInfo.EnumerateFiles
    • This returns IEnumerable<FileInfo>.
  • Directory.EnumerateFileSystemEntries
    • This returns IEnumerable<string> of the file system entries.
  • DirectoryInfo.EnumerateFileSystemEntries
    • This returns IEnumerable<FileSystemInfo>.
  • File.ReadLines
    • This returns IEnumerable<string> where each string is a line from text file.
11 May 2010

.NET Baby Steps: Part VII - Caching

Photo296 Note: This post is part of a series and you can find the rest of the parts in the series index.

.NET has had one out of the box way to do caching in the past, System.Web.Caching. While a good system it suffered from two issues. Firstly it was not extensible, so if you wanted to cache to disk or SQL or anywhere other than memory you were out of luck and secondly it was part of ASP.NET and while you could use it in WinForms it took a bit of juggling.

The patterns & practises team saw these issues and have provided a caching application block in their Enterprise Library which has been used by everyone who did not want to re-invent the wheel. Thankfully from .NET 4 there is a caching system now included in the framework which solves those two issues above. This is known as System.Runtime.Caching.

Slow Example

To see how to use it lets start with a process which we can cache. I have a class called Demo which has a property named Times which is of type IEnumerable<DateTime>. To set the value of Times, you call the SetTimes method and that populates the property with 5 values. However there is a delay of 500ms between each adding of DateTime to the Times property, so it takes 2.5secs to run. In my Program class I have a method, PrintTimes which creates a new Demo object, calls SetTimes and then prints the value to screen. Lastly I in my Main method I call PrintTimes three times – in total it takes 7.5secs to run.

class Program
    {
        public static void Main()
        {
            PrintTimes();
            PrintTimes();
            PrintTimes();
        }

        private static void PrintTimes()
        {
            Demo demo = new Demo();            
            Stopwatch stopwatch = Stopwatch.StartNew();
            demo.SetTimes();
            foreach (DateTime time in demo.Times)
            {
                Console.WriteLine(time);
            }
            stopwatch.Stop();
            Console.WriteLine("It took {0} to print out the times", stopwatch.ElapsedMilliseconds);
        }
    }

    class Demo
    {
        public List<DateTime> Times { get; set; }

        public void SetTimes()
        {

            if (Times == null)
            {
                Times = new List<DateTime>();
                for (int counter = 0; counter < 5; counter++)
                {
                    Thread.Sleep(500);
                    Times.Add(DateTime.Now);
                }
            }

        }
    }

The output is from this example code is below. Note the times printed are constantly changing and that it takes ~2500ms to print out each set of values.

 image

Cache Example

Now I change the PrintTimes method to incorporate the caching by creating an ObjectCache which I set to use the default MemoryCache instance. I can check if the cache contains an object using the .Contains method, I retrieve from the cache using the .Get method and I add to the cache using the .Add method:

private static void PrintTimes()
{
    Demo demo;

    Stopwatch stopwatch = Stopwatch.StartNew();
    
    ObjectCache cache = MemoryCache.Default;
    if (cache.Contains("demo"))
    {
        demo = (Demo)cache.Get("demo");
    }
    else
    {
        demo = new Demo();
        demo.SetTimes();
        cache.Add("demo", demo, new CacheItemPolicy());
    }

    foreach (DateTime time in demo.Times)
    {
        Console.WriteLine(time);
    }
    stopwatch.Stop();
    Console.WriteLine("It took {0} to print out the times", stopwatch.ElapsedMilliseconds);
}

This gives the output:

 image

Note the time to print out for the first one is about 60ms longer but the second two is down to 0ms and also note how the values in the three sets in are the same.

CacheItemPolicy

In the above example I just use a default CacheItemPolicy, but you could do a lot more with the CacheItemPolicy:

  • AbsoluteExpiration: Set a date/time when to remove the item from the cache.
  • ChangeMonitors: Allows the cache to become invalid when a file or database change occurs.
  • Priority: Allows you to state that the item should never be removed.
  • SlidingExpiration: Allows you to set a relative time to remove the item from cache.
  • UpdateCallback & RemovedCallback: Two events to get notification when an item is removed from cache. UpdateCallback is called before an item is removed and RemovedCallBack is called after an item is removed.

Things to watch out for

  • .NET 4 only ships with support for memory caching out of the box, so you will need to build your own provider if you want any other cache source.
  • You must add the System.Runtime.Caching.dll reference to get access to the namespace and classes.
  • This is NOT part of the .NET 4 client profile, it is only in the full .NET 4 Framework. I have logged an issue with Connect to move the assembly into the client profile and if you agree with this idea, please vote on it: 558309

Pages