Search results matching tag 'C# 3.0'

Understanding Lambda Expressions

NathanZaugg — Tue, 20 Jan 2009 20:20:00 GMT

This post has been sitting in my drafts for months! Because my friend Phil just posted his post on Lambda Expressions I'll simply link to his post and present the rest of this as supplemental examples.

// Delegates
// My Blog Engine is having trouble showing these so there may be some extra spaces
public delegate IntMathExpression (int x, int y);
public delegate IntMathExpressionSingle (int x);
public delegate FloatMathExpression (float x, float y);

// Basic Lamda Expression
IntMathExpression a = (int x, int y) => x * y;
IntMathExpression b = (int alpha, int brovo) => alpha * brovo;
IntMathExpressionSingle c = (int x) => x * x;

// "such that" => 
// Parameters       => function body
// (param1, param2) => param1 + param2

// Lamda Expression using Type Inference
FloatMathExpression d = (x, y) => x + 3.14f * y;

// There is usually no need for custom delegates
Func<float, float, float> e = (x, y) => x * 100.0f + y;

// Example using a lamda expression
List<int> primes = new List<int>() { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101 };
var p = primes.Where( prime => prime.ToString().EndsWith( "3" ) );

// Deferred Execution
foreach (int i in p) {
    MessageBox.Show(i.ToString());
}

// Query Expression Format
var p2 = from prime in primes
         where prime.ToString().EndsWith("3")
         select prime;

List<int> results = p2.ToList();

// Lamda Expressions mixed with Extension Methods
List<string> str = new List<string>() { "The Lord of the Rings", "Star Wars, Eposode III", "Ratatouille" };

var p3 = from movie in str
         where movie.CountVowels() > 5
         select movie;

List<string> movieResults = p3.ToList();

Bug in Visual Studio 2008 SP1?

NathanZaugg — Mon, 15 Sep 2008 17:25:00 GMT

This is just a quick post. I had a bug where any time I tried to compile a WPF project on my laptop I got the following pair of errors:

Error Message 1:
The "SplashScreen" parameter is not supported by the "MarkupCompilePass1" task. Verify the parameter exists on the task, and it is a settable public instance property.

Error Message 2:
The "MarkupCompilePass1" task could not be initialized with its input parameters.

I completely uninstalled Visual Studio 2008 & SP1 and reinstalled everything and this did not go away. Anyway, here is how you fix it:

Using a text editor, open the file: C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.WinFx.targets
Search for "MarkupCompilePass1"; this was line 294 for me
Remove the following line from the XML tag line: SplashScreen="@(SplashScreen)"

I have also posted my work around on the Microsoft Connect site (link below).

Links:

.NET Threading :: Part 1 - Basic Threading

NathanZaugg — Tue, 09 Sep 2008 19:18:28 GMT

Recently I have been doing a lot with threading. This is a concept that used to be very difficult for me and now is only just difficult! Threading is becoming increasingly important as modern processors are not getting faster, they are getting more cores. In order for a application to utilize any of the power of modern CPU's it must use threading! So I thought I would take a second and go through all of the classes in the System.Threading namespace. We'll start with the simple stuff and move on to more advanced stuff!

The most familiar and basic structure for locking in .net is the lock statement shown below:

lock (this) {
    ObjectCount = value;
}

The lock is a simple synchronization structure which will only allow a single thread into the "critical" locked section at a time. Many people don't realize this but the following code does the exact same thing:

Monitor.Enter(this);
    ObjectCount = value;
Monitor.Exit(this);

In fact, the Monitor object can do a lot more than enter a critical section; though I've not found a lot of use for the other functions. But some operations of note are Monitor.TryEnter which allows you to specify a time span to wait for the lock. Monitor.Pulse and Monitor.PulseAll notify the next waiting thread or all waiting threads respectively that a lock has been released. This is not necessarily required but may result in the next thread being able to enter the critical section a bit quicker. Monitor.Wait will release the lock to let another thread enter and then re-acquire the lock.

Another note-worthy threading trick is the keyword volatile. This designation is useful in conditions where we are waiting for a variable to be changed in a while loop. The C# compiler is really smart and usually assumed volatility for you, but it's a great habit to use it explicitly. Basically what it does is it does not allow the value of a variable to be cached in a register or a stack. Any time the value is referenced it will be pulled from it's memory location on the stack. If this were not the case the value could change and you may never break out of the while loop. Here is a quick example:

private volatile bool IsCanceled;

private void RunThread(object state) {
    while (!IsCanceled) {
        // Do work here!
    }
}

In the code block above, if some other thread changes the state of IsCanceled then the while loop will stop and the thread will exit. While this is the behavior you would expect anyway the compiler might not agree with you (especially if there is late-binding or the value is modified outside of the scope of the class). This keyword only works on fields, not properties and should only be used where it must as it will adversely affect performance. Again, it's just good practice to use it when reading a value that can be mutated by another thread.

One of my favorite patterns is the singleton pattern. This pattern is the most widely recognized but the least understood. Lets take a second to examine a standard implementation of the singleton pattern.

public class SingletonExampleClass {

    private static volatile SingletonExampleClass _instance = null;

    public static SingletonExampleClass Instance {
        get {
            if (_instance == null) {
                lock (typeof(SingletonExampleClass)) {
                    if (_instance == null) {
                        _instance = new SingletonExampleClass();
                    }
                }
            }
            return _instance;
        }
    }
}

As you can see from the code above we have to implement double-checking. The reason is that after the evaluation another thread could be slightly ahead and have created the object just ahead of you. You could lock the type before doing your check in the first place but locking is expensive and completely unnecessary most of the times. Only the first call requires the lock, after that all other calls simply want an a reference to that class. Singleton is a very important pattern for serialization and is one of the most common, that's why Microsoft gave us a break here with the readonly keyword. The same section of code above can be written as:

public class SingletonExampleClass {

    public static readonly SingletonExampleClass Instance =

        new SingletonExampleClass();

}

Much simpler! It literally eliminated 12 lines of code! This is more or less the same as it's brother. The only difference is the lazy instantiation in the first example, but in almost all cases this pattern is simpler and more intuitive. This pattern is also a little more flexible as it will allow you to use readonly on non-static fields as well. Additionally you may instantiate the value in the constructor rather than the initializer, but you must do one or the other. Also, once the value is set it may not be changed!

Another favorite of mine is the Interlocked class. Interlocked.Increment and Interlocked.Decrement allows you to increment or decrement an numeric value using a thread-safe mechanism.

private int ItemsProcessed = 0;

private void RunThread(object state) {
    List<Order> orders = state as List<Order>;
    
    if ( orders == null )
        return;

    foreach (Order ord in orders) {
        // Process Order
        // ...
        Interlocked.Increment(ref ItemsProcessed);
    }
}

As you can see, it's pretty simple to use. You may be wondering about the use of ref in the function signature. Well, as you know int and long are value types (structs) and would be passed to any function by value (copying the contents to the function). When we use the ref function signature it tells the compiler that we don't want to pass a copy of this value to the function, we want to pass the actual variable. I.E. we passed a pointer to the variable rather than the value of it. This means that any mutations made to the variable inside of the function are effective outside of the function.

The next basic structure I'd like to discuss is a Mutex. A Mutex is a lot like the Monitor object I showed above and a ManualResetEvent but can work between different processes, not just different threads. The specifics of a Mutex are best described in this snippit from the MSDN documentation:

Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. A local mutex exists only within your process. It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Each unnamed Mutex object represents a separate local mutex.

Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

Note:

On a server that is running Terminal Services, a named system mutex can have two levels of visibility. If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it wa s created . In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server . If you do not specify a prefix when you create a named mutex , it takes the prefix "Local\". Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes .

Note:
On a server that is running Terminal Services, a named system mutex can have two levels of visibility. If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it wa s created . In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server . If you do not specify a prefix when you create a named mutex , it takes the prefix "Local\". Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes .

Here is a short sample that checks for the an existing Mutex and exits if found. This is useful for single-instance applications.

static class Program {

    static Mutex m;

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main() {
        // Check for single instance of our application
        bool createdNew;
        m = new Mutex(true, "TestThreadingApplication", out createdNew);
        if (!createdNew) {

            m.ReleaseMutex();
            return;

        }
        
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());

        m.ReleaseMutex();
    }
}

The code works by trying to get an existing Mutex named "TestThreadingApplication". If that Mutex does not exist in the Operating System it will be created and your thread will be assigned the owner. If you were the first instance you will have created the Mutex and you may resume execution, otherwise your application will exit.

The last thing we will discuss in this post is a Semaphore. A Semaphore works much the same way as a Mutex, but works best as a way to manage a pool of objects. The Semaphore starts with an initial count of objects. Each time the WaitOne method is called the count will be decrement. When the count reaches zero threads will be blocked until another thread calls Release. Unlike the Mutex, the Semaphore does not track which threads have incremented or decremented the internal count so the programmer must be careful to Release the exact number of times WaitOne is called. It's best to think of a Semaphore as a synchronization mechanism that can let more than one thread into the critical section. Because of it's similarity to other synchronization objects I didn't create a sample code block.

Avoiding Circular Dependencies

NathanZaugg — Mon, 09 Jun 2008 21:45:06 GMT

The term "circular dependency" may be foreign to some programmers (especially if you do Java as it is a pretty common practice). However, anyone who has done some scripting for a referential database knows that you have to run scripts in a certain order. Running scripts out of order causes errors when you run. The interesting trick is that if you run that same incorrectly-ordered DDL script again and again you will eventually get it to run without errors. If you were unaware of the order being incorrect and thought to yourself in that moment "Stupid database!" then this blog post is for you!

What is a circular dependency?

It is simply two libraries that use each other (either directly or indirectly) as shown below:

Figure 1: Circular Dependency

Figure 2: Complex Circular Dependency

The complexity of a circular dependency may vary. If you are using Visual Studio and have all of your projects loaded into a single solution AND you add Project References (Right click on project -> Add Reference -> Projects Tab -> {Project Name}) then the IDE will not allow you to create Circular Dependencies. In fact, this is a good practice as Visual Studio will ensure the correct build order.

Why are circular dependencies bad?

Just like our Database example above, a circular dependency makes it so you can not guarantee that your application has the latest code. That is a big deal! Here is why:

I make changes to Application 1 (in Figure 2)
I build my project, The changes I made in Application 1 may or may not have gotten into Application 2 (depending on build order). It may have taken a copy of the compiled code that was left over from the last time I built.
Application 2 depends on this new functionality to provide services to Application 3; This functionality will not work correctly with this build.
Application 3 may or may not depend on these same services to provide back to Application 1

As you can see in this scenario, there is no such thing as a "correct" build order when there are these circular dependencies. The only way you can arrive at the correct version of the code is to build it as many times as there are nodes in our circle. That would mean for Figure 1 that we would need to build twice and three times for Figure 3. Some of these dependencies can get really ugly! Here is some actual code running in an actual company that I did analysis on some time ago using a tool called Structure 101.

How do I fix circular dependencies?

There are some steps to take to solve even the most complex tangles! They all involve refactoring your code though.

Refactor common code into a "base" dependency; I usually call this "Common" (figure 3). BEST SOLUTION
Remove code that is unused. In the tangles shown above many of them are using deprecated/unused code.
Duplicate the sections of code used. This should be seen as a last resort but given the choice between code duplication and circular dependencies, I take code duplication ever time!

Figure 3: Refactor a Common

Summary

There are two kinds of design concepts for nTier (and other types of architectures as well) called Logical Layout Design and Physical Layout Design. The Logical Layout is simply that your software occupies the same project/package but leverage different classes. In contrast Physical Layout Design forces each tier to be separated into different Projects/Packages. So long as we are careful to manage the dependencies between these packages from the start this is the preferable way to code. While the logical layout does not suffer from the dependency problem eventually you may wish to break these classes apart and find that there are a lot of inner-dependency that should not exist simply because they occupied the same project. Remember to keep it clean!

XAML Cheat Sheet

NathanZaugg — Thu, 29 May 2008 04:33:05 GMT

A few weeks ago I gave a presentation on Silverlight at the Utah Code Camp. I was really impressed by a presentation I saw last time on Ruby and everyone really liked the cheat sheet that was provided. For my presentation this year I created an XAML Cheat Sheet. For those who are learning XAML it is a pretty good resource but it's most helpful for me when I know how to do something but I can't remember the syntax. This is a work in progress so keep on checking back. It can be downloaded in the Media section of this site or by clicking here.

Please drop me a line if you think you have something useful to add or you want to thank me for the hard work it took to put this thing together!

Nathan Zaugg

SP1 for the .Net Framework 3.5 and Visual Studio 2008 Released to Beta

NathanZaugg — Mon, 19 May 2008 18:34:00 GMT

As promised by Microsoft when Visual Studio 2008 launched late last year, there is a service pack for available both for the .Net framework 3.5 and Visual Studio 2008. Information about the release can be found on ScottGu's Blog and mostly include bug fixes and performance enhancements, but the points of interest for me are:

ASP.NET Routing Engine which gives you the ability to map URL's to route handlers. For example the URL http://www.mysite.com/myapp/data/234/editComment
ASP.NET AJAX Back/Forward Button History Support gives you the ability to control the forward & back button clicks on the browser. This will be very useful for "single page" ASP.NET AJAX implementations.
Performance improvements on the web editor in VS 2008.
JavaScript Formatting Settings
CLR performance improvements including startup times that are 40% faster and faster ASP.NET requests (up to 10% faster).
WPF New Features and Performance Enhancements!
- Performance enhancements using GPU
- New "WritableBitmap" which allows for tear-free bitmap updates.
- ListBox, ListView, and TreeView now support "item container recycling" and virtualization which results in better performance. This will have a huge effect on large amounts of data.
- Deferred Scrolling which doesn't render until the mouse up on a scroll event. This will can have a enormous effect on huge data sets.
- StringFormat support within binding expressions
- New Alternating Rows support for controls derived from ItemControl
- Events tab support within the property browser in VS 2008
- Go to Definition and Find All References now support things declared in XAML
SQL Server 2008 Support
The long awaited ADO.NET Entity Framework which includes integration with any database
Improvements in WCF including scailability, ADO.NET Entities in service contracts, and Improved Debugging support for WCF.
Improvements to C#; The C# code editor now identifies and displays red squiggle errors for many semantic code issues that previously required an explicit compilation to identify. The debugger in VS 2008 SP1 has also been improved to provide more debugging support for evaluating LINQ expressions and viewing results at debug time
Fixes to TFS

Installation Cautions

If you are running this on Vista, be sure Vista SP1 is installed!
If you have installed the VS 2008 Tools for Silverlight 2 Beta1 package on your machine, you must uninstall it - as well as uninstall the KB949325 update for VS 2008 - before installing VS 2008 SP1 Beta
If you are running anything earlier than Expression Blend 2.5, then you need to update it to the latest. Earlier versions will cease to run.
This is still beta software -- Install at your own risk!

A direct download link can also be found here: http://msdn.microsoft.com/en-us/vstudio/products/cc533447.aspx

--Nathan Zaugg

January 2008 NUNUG Notes

NathanZaugg — Tue, 05 Feb 2008 21:40:00 GMT

I am a little behind on my Blog but I wanted to be sure and post my notes from January's NUNUG meeting on Visual Studio 2008 and the new features in the C# 3.0 framework.

I also wanted to post notes from a remoting presentation I did for STG a year or so ago.

Enjoy!

Downloads

iGen :: Open Source XSLT Code Generation Application

NathanZaugg — Wed, 23 Jan 2008 21:41:00 GMT

I have decided to open source a project that I have been working off and on since 2003. I have always been a big fan of code generation and felt like I knew what it takes to do it right. iGen is actually the second separate attempt. My original attempt is named SmartDAL and is also included in the downloads below.

What is iGen?

iGen is simply a fancy XSLT processing engine. It works by having 2-3 main concepts.

XML Provider - The XML provider is responsible for providing XML to the XSLT templates. Currently it has Oracle provider and SQL Server provider. Each of these will generate SQL that will be used in the XSLT transformation.
XSLT Transformations - The XSLT transformations are a set of files that will transform the XML that is generated from the XML Provider. The transformations also use a standard set of variables and accepts custom variables.
File Splitter - The result of an XSLT transformation results in a single file only. If you wish for multiple files as the output then you need to use the built-in splitter.

This is the main screen. The top portion is our XML Providers. You can see that both SQL Server and Oracle are there. This is where you configure which tables, proc's, and database relationships will be used to generate the XML data. It may be desirable to leave out certain tables or proc's so you can choose which ones you wish to include.

The options screen is used to setup project workspaces. The idea behind this concept is that ever developer has their favorite place they like to develop code. I like to have a D:\Projects\[Client]\[Project] structure. Others use C:\Source. Whatever the path it's nice to keep those different and still be able to generate code! We will use these workspaces in later screens.

This next screen shot is of the XSLT settings dialog. Let me go through the controls one by one.

Settings Description - This is simply the text that will be displayed in the parent dialog. Generally a short description of what you this template does is best.
XSLT Template - This is the location of the template you wish to process. Notice that there is a drop-down box and a partial path. This is part of the workspaces mentioned above. Of course the path does not need to be part of the workspace provided. This should always be a valid XSLT transformation.
Data Provider - This selects which XML Data Provider will be used for this transformation. Because the XML that is generated does not have to follow any specific schema you are required to select a provider that is compatible with the XSLT.
Filename Extension - This gives the user the ability to name the file output. If you are generating a single file then type the entire file name here. If you are generating multiple files then put a suffix if desired and the filename extension. In the example above the files will end with "_INSERT.sql". The rest of the filename is generated by the XSLT transformation.
Workspace / Path - This is the output directory for the transformation. Again, you can see that we are using a different workspace than defined above. If you browse to a directory that is inside of the selected workspace path then you will only see a partial path in this box. Otherwise you will see a full path.
Parameter Window - This is where you can add custom parameters for your XSLT. These parameters can be found inside of the XSLT defined at the top of the file. These parameters can be optional but it really depends on how the XSLT was written.

You press the generate button and away we go. You will see what is happening and how long until it finishes. When you are done you may choose to save your settings (after all it can be a lot of work setting these templates up).

This is an XSLT template. You can see from the screen shot (params highlighted in yellow) that this transformation expects 5 params. ProcPrefix, FileNameExtension, DatabaseSchema, DatabaseName, and DatabaseUserName (in no particular order). The FileNameExtension parameter is provided by the XSLT properties window in the "Filename Extension" fields. The rest are custom parameters and the XSLT generation engine will not know if they are required or not. As you can see from the screen shots above I have defined all but the "ProcPrefix". This template is designed to make ProcPrefix optional. It will run just fine without it. But for those who like all of their stored procs to start with "proc_" or "sp" then they may choose to set a value for this parameter in the Parameter window in the XSLT properties dialog.

Note also the use of "#[<xsl:value-of select="@name" /><xsl:value-of select="$filenameextension" />]#" in the example. The #[ and ]# are used by the file splitter. The value inside of the tokens is used as the filename. Ex: #[proc_USERS_INSERT.sql]#

If you wish to create a custom XML Provider you simply need to implement the correct interface and place the DLL in the application directory during startup.

Known Issues:

The Oracle XML provider is a little more advanced than the SQL XML provider. The oracle provider will provide relationship information that the SQL provider does not yet.
The Oracle provider is dog slow! This is actually a performance issue with querying relationship information from an Oracle database. For those who have to use this, I am sorry! If it makes you feel better the XML data is cached once it is created so if you goof up on the first run the second one will be much faster.
The generated classes are somewhat geared toward an Oracle Smart-Client application. These templates and classes were all "perfected" with the Oracle client. I much prefer to use Microsoft SQL Server 2005/2008 but sometimes you don't get to choose! If you wish to modify the templates to work for SQL Server it probably isn't a lot of work.
.tmp files are left over after generation. These are the original results from the transformation. They can be useful for debugging.
There is a "lib" directory inside of the templates directory. This is an open source XSLT function library. We use it to mainly make sure the case of our objects is what we need it to be.

Screen Shot of SmartDAL:

I hope you enjoy it! Please drop me a line if you download it and if you are using it.

Downloads:

Thanks!
Nathan Zaugg

Credits
I wasn't alone in working on iGen. I had a lot of help from the team that used it. Bret Cutler, Richard Brower, and Garth Harris. An awesome team -- I would love to work with these guys on another project!