Random .Net Stuff

ADO .NET Entity Framework Vote of No Confidence

bill — Mon, 23 Jun 2008 14:26:00 -0700

Read it. Sign it.

http://efvote.wufoo.com/forms/ado-net-entity-framework-vote-of-no-confidence/

Defensive Event Publishing

bill — Mon, 26 May 2008 15:48:00 -0700

How does one go about publishing event in a safe way so that one could minimize the chance of exceptions? Let's say you have a class such as this:

public class MyClass
{
public event EventHandler MyEvent;
}

The first thing that comes to mind when you want to publish MyEvent would be to just invoke the delegate.

MyEvent(this, EventArgs.Empty);

The first issue that you would find is that if no one has subscribed to the event then just invoking the delegate would cause a null reference exception. So we need to check for null.

if ( MyEvent != null )
MyEvent(this, EventArgs.Empty);

This leads to another issue. Someone could unsubscribe from the event handler after we check for null which would lead to another null reference exception when we invoke the delegate. Since delegates are immutable we can copy the delegate to a variable and it will keep its state even if someone unsubscribes from the event. So we assign it to a variable, check the variable for null then invoke.

EventHandler handler = MyEvent;
if (handler != null)
handler(this, EventArgs.Empty);

That much code for invoking a delegate smells bad and needs to be moved to its own method. So we refactor using ExtractMethod and create an OnMyEvent method.

protected void OnMyEvent()
{
    EventHandler handler = MyEvent;
    if (handler != null)
        handler(this, EventArgs.Empty);
}

Now that we have the method there is one hidden issue that most people don't realize could cause us problems which is compiler optimization. The JIT compiler might decide to optimize our method, removing our variable and just make the call directly to the event delegate leaving us open for another null reference exception. We can stop that from occurring by adding an attribute which will tell the compiler to not optimize the method.

[MethodImpl(MethodImplOptions.NoInlining)]
protected void OnMyEvent()
{
    EventHandler handler = MyEvent;
    if (handler != null)
        handler(this, EventArgs.Empty);
}

This gives us a self contained safe and easy way to raise the event.

Vista Sidebar CC.Net Monitor

bill — Sat, 23 Jun 2007 20:38:00 -0700

Note to self....

http://gallery.live.com/LiveItemDetail.aspx?li=5b50b967-4961-4cf6-8c3d-456db65cba17

http://codeclimber.net.nz/archive/2007/07/15/CruiseControl.NET-Monitor-Vista-Gadget-version-0.9.5.aspx

Windows 2003, IIS 6, FileStream, UnauthorizedAccessException

bill — Mon, 02 Apr 2007 20:22:00 -0700

Hopefully, if you are getting an UnauthorizedAccessException in IIS 6 while trying to write out a file this will help you.

Today a client was frustrated after rolling out an application from staging to live. The web application created thumbnails on the fly and caches those thumbnails to disk using a FileStream. The code worked fine in the dev environment and in the staging environment, but as soon as it went to the live server it started throwing an UnauthorizedAccessException whenever the file was being written.

After searching Google for the terms in this posts subject I finally came across what I thought might fix the problem, sure enough it did. The IIS_WPG group must have the correct rights in the folder you are trying to write files to.

---------------------- Snip of the error -------------------
UnauthorizedAccessException: Access to the path '[THE_PATH_WAS_HERE]' is denied.]
System.IO.__Error.WinIOError(Int32 errorCode, String maybeFullPath) +2013027
System.IO.FileStream.Init(String path, FileMode mode, FileAccess access, Int32 rights, Boolean useRights, FileShare share, Int32 bufferSize, FileOptions options, SECURITY_ATTRIBUTES secAttrs, String msgPath, Boolean bFromProxy) +998
System.IO.FileStream..ctor(String path, FileMode mode) +65

Simulating Persisted StateMachine Workflows

bill — Fri, 30 Mar 2007 11:18:00 -0700

I wanted the unit tests for a StateMachineWorkflow to act as if they are persisted so I created the InMemoryPersistenceService. Basically the service serializes the activities to memory then stores them as byte arrays in dictionaries using the guid as the key. Fairly simple stuff, but usefull.

InMemoryPersistenceService .cs (5.64 kb)

Multiple Generic Types + Multiple Constraints

bill — Sun, 07 Jan 2007 11:02:00 -0700

I could not remember how to do this (I kept trying to use a comma).

public T CreateSomething<U, V>()
    where T : SomeObject
    where U : SomeObject<V>
    where V : SomeThingElse, new()
{
    return .....
}

Nesting Project Items

bill — Wed, 03 Jan 2007 13:56:00 -0700

I don't really understand why this isn't built in to vs.net. Delarou's macro makes life alot easier if you want to do any item nesting.

---

"This macro enables you to nest project items inside Visual Studio .NET. Until now, there is no easy way to nest project items through the Visual Studio IDE, you can only do it by manipulating the project (.csproj or .vbproj) file and adding the DependentUpon element."

GridView Combined ImageField and HyperLinkField

bill — Fri, 08 Dec 2006 21:50:00 -0700

Is it so hard to imagine that someone someday would want to link an image to something from within the GridView? You can't just set some link properties on the ImageField or set some image properties on the HyperLinkField. So I broke out Reflector and made an ImageLinkField.

ImageLinkField .cs (12.75 kb)

C# Exception Class Template

bill — Tue, 21 Nov 2006 08:26:00 -0700

Download the ExceptionClass.zip (1.53 kb) and place it in [Drive]:\Documents and Settings\[User]\My Documents\Visual Studio 2005\Templates\ItemTemplates\Visual C#\.

The next time you go to add a file, ExceptionClass should be in your "My Templates" section at the bottom.

Simple ClickOnce Utils

bill — Wed, 08 Nov 2006 19:59:00 -0700

Two simple methods for ClickOnce deployed applications.

public static class ClickOnce
{
    /// <summary>
    /// Determines whether this instance is deployed.
    /// </summary>
    /// <returns>
    ///     <c>true</c> if this instance is deployed; otherwise, <c>false</c>.
    /// </returns>
    public static bool IsDeployed()
    {
        return (AppDomain.CurrentDomain.ActivationContext != null && ApplicationDeployment.IsNetworkDeployed);
    }

    /// <summary>
    /// Parses the query string.
    /// </summary>
    /// <returns><see cref="NameValueCollection"/> containing the key/value pairs from the ActivationUri if they are found; otheriwise an empty <see cref="NameValueCollection"/>.</returns>
    public static NameValueCollection ParseQueryString()
    {
        if (!IsDeployed())
            return new NameValueCollection();

        Uri uri = ApplicationDeployment.CurrentDeployment.ActivationUri;
        if (uri != null)
        {
            NameValueCollection parms = HttpUtility.ParseQueryString(uri.Query);
            if (parms.Count != 0)
                return parms;
        }

        return new NameValueCollection();
    }
}

Enum Helper Class Using Generics

bill — Wed, 01 Nov 2006 20:23:00 -0700

A week or so ago I came across this post in microsoft.public.dotnet.languages.csharp asking about using Generics to make dealing with bitwise operations on enums that have the FlagsAttribute. I was thinking that even though you can't use an Enum as Generic Constraint you can probably fudge it just enough to make a usefull class. So I posted my answer to the question and then decided to write my Enum<T> class. Yes, I actually named the class Enum<T>.

Enum.cs (17.12 kb)

public class Class1
{
    [Flags]
    public enum FlaggedEnum
    {
        None = 0,
        Red = 1,
        Blue = 2,
        White = 4,
        Black = 8,
        Green = 16
    }

    public enum MyTestEnum
    {
        [Description("This is a description")]
        Val0,
        Val1,
        Val2
    }

    static void Main(string[] args)
    {
        MyTestEnum a;
        Enum<MyTestEnum>.TryParse("Val1", out a);
        Debug.WriteLine(a); // output: Val1

        bool returnValue = Enum<MyTestEnum>.TryParse("Val3", out a);
        Debug.WriteLine(returnValue); // output: False

        MyTestEnum? b;
        Enum<MyTestEnum>.TryParse("Val2", out b);
        Debug.WriteLine(b); // output: Val2

        Enum<MyTestEnum>.TryParse("Val3", out b);
        Debug.WriteLine(b); // output: nothing

        //Enum<MyTestEnum>.Flags.IsFlagSet(a, MyTestEnum.Val2); // raises an assert by design
        //int test;
        //Enum<int>.TryParse("hello", out test); // raises an assert by design

        // Flags Methods
        FlaggedEnum flagged = FlaggedEnum.Red | FlaggedEnum.Blue | FlaggedEnum.White;
        Debug.WriteLine(flagged); // output: Red, Blue, White

        flagged = Enum<FlaggedEnum>.Flags.SwapFlag(flagged, FlaggedEnum.Red);
        Debug.WriteLine(flagged); // output: Blue, White

        flagged = Enum<FlaggedEnum>.Flags.SwapFlag(flagged, FlaggedEnum.Red);
        Debug.WriteLine(flagged); // output: Red, Blue, White

        flagged = Enum<FlaggedEnum>.Flags.ClearFlag(flagged, FlaggedEnum.White);
        Debug.WriteLine(flagged); // output: Red, Blue

        flagged = Enum<FlaggedEnum>.Flags.SetFlag(flagged, FlaggedEnum.White);
        Debug.WriteLine(flagged); // output: Red, Blue, White

        // using the ref overrides
        Enum<FlaggedEnum>.Flags.SwapFlag(ref flagged, FlaggedEnum.White);
        Debug.WriteLine(flagged); // output: Red, Blue

        Enum<FlaggedEnum>.Flags.SetFlag(ref flagged, FlaggedEnum.White);
        Debug.WriteLine(flagged); // output: Red, Blue, White

        IList<int> values = Enum<FlaggedEnum>.GetValues<int>();

        string name = Enum<FlaggedEnum>.GetName(2);
        Debug.WriteLine(name); // output: Blue

        DescriptionAttribute attrib = Enum<MyTestEnum>.Reflection.GetAttributeOnValue<DescriptionAttribute>(MyTestEnum.Val0);
        Debug.WriteLine(attrib.Description); // output: This is a description

        // For WinForms DataBinding
        IList<IBindableEnum<MyTestEnum>> list = Enum<MyTestEnum>.DataBinding.CreateList();
        foreach( IBindableEnum<MyTestEnum> bindable in list )
            Debug.WriteLine(String.Format("{0} : {1}", bindable.Name, bindable.Value));
        // output:
        // Val0 : Val0
        // Val1 : Val1
        // Val2 : Val2

        list = Enum<MyTestEnum>.DataBinding.CreateList
        (
            delegate(MyTestEnum target)
            {
                return target.ToString().Replace("Val", "Value ");
            }
        );
        foreach (IBindableEnum<MyTestEnum> bindable in list)
            Debug.WriteLine(String.Format("{0} : {1}", bindable.Name, bindable.Value));
        // output:
        // Value 0 : Val0
        // Value 1 : Val1
        // Value 2 : Val2
    }
}

Windows Forms Flicker Fix Using SendMessage

bill — Tue, 17 Oct 2006 22:16:00 -0700

A simple way to stop forms/controls from flickering. The zip file contains the WindowLock class.

using (IWindowLock windowLock = WindowLock.CreateLock(control))

{

    // do stuff....

}

External.Windows.zip (8.48 kb)

Implementing IPersistComponentSettings

bill — Sat, 14 Oct 2006 22:42:00 -0700

IPersistComponentSettings is defined by MSDN as a standard functionality for controls or libraries that store and retrieve application settings. Yes, MSDN does define it and it shows you all the properties and methods on the interface, however it does not tell you how to use it at all.

In the simplest case you need a class which inherits from System.Configuration.ApplicationSettingsBase to store your settings. Your control (or UserControl) needs to implement the IPersistComponentSettings and have it’s SaveSettings property set to true. It is also a good idea to set the SettingsKey property to something specific. The name of control seems to work fine.

LoadComponentSettings(): retrieve your properties from the ApplicationSettingsBase class and set the values on the control.

SaveComponentSettings(): set the properties on the ApplicationSettingsBase class and then call the Save() method on that class.

ResetComponentSettings(): call Reset() on the ApplicationSettingsBase class.

I have not figured out how or if something else should be forcing a save by calling SaveComponentSettings automatically, so in my control I added an override to the Dispose method and call SaveComponentSettings myself.

IPersistComponentSettingsExample.zip (14.72 kb)

A simple way to get the Desktop Width/Height across all monitors

bill — Sat, 14 Oct 2006 14:37:00 -0700

You would think that System.Windows.Forms.Screen would have a property for the whole desktop, but it doesn't. If you are looking to get the actual desktop width and height across all monitors you need to use.....

System.Windows.Forms.SystemInformation.VirtualScreen

VS.Net 2005 taking forever to close files

bill — Thu, 12 Oct 2006 07:57:00 -0700

I have a large solution w/ 30+ projects and everytime I closed a file in the IDE it took almost 10 seconds to close. I found that when I deleted the slutions .suo (solution user options) file this fixed my problem. I have no idea what that thing was doing, but it seemed to fix it.