Archive for the ‘Development’ Category

How to Set List Folder Contents

July 21st, 2010 Richard No comments

This is a reminder for myself more than anything.

To set "List Folder Contents" on a folder you need to set:





The only difference between "List Folder Contents" and "Read & Execute" is that List Folder Contents is only inherited by folders rather than by folders and files.

Categories: Development Tags: ,

Update a Dll in the GAC From the Command Line

July 7th, 2010 Richard No comments

I’ve blogged before on how to Easily add a dll to the GAC, but that involves two instances of Windows Explorer and the mouse.

It would be quicker and easier to use the command line to update a dll in the GAC. You can do this with the Global Assembly Cache Tool gacutil, but this is only present if you have the .net SDK or Windows SDK installed. This is going to be the case with your development machine, but you don’t really want to be installing it on all your test servers.

To get round this I knocked up a quick utility which will remove an existing version of a dll from the GAC and then install the latest version. The code is:

using System;using System.Globalization;using System.EnterpriseServices.Internal;

namespace Test{    public class GacInstall    {        public static void Main(string[] arguments)        {            try            {                string assemblyPath = arguments[0];                Publish publish = new Publish();                publish.GacRemove(assemblyPath);                publish.GacInstall(assemblyPath);            }            catch (Exception e)            {                Console.WriteLine(e);            }        }    }}

You can then use it by passing it the dll you want as a command line parameter e.g.

GacInstall MyUpdatedCode.dll

Assuming that MyUpdatedCode.dll is in the same directory.

Combined with my last tip Recycle An Individual Application Pool From The Command Line you can now write a bat or cmd file to replace the dll in the GAC and recycle the application pool with 2 key presses: The up arrow key and then return.

Recycle An Individual Application Pool From The Command Line

July 7th, 2010 Richard No comments

When developing SharePoint artifacts which live in the GAC you have the following options to get your new release in as part of the development process:

  1. Build your installation package and upgrade it
  2. Put the new dll in the GAC and run iisreset
  3. Put the new dll in the GAC and recycle the SharePoint application pool
    This is because SharePoint will only pick up updated dlls in the GAC after a recycle.

As it is an iterative process when you are developing this happens a lot, so ideally you need a process which is as quick as possible. 1 & 2 take the longest time so you should aim to use 3.

Luckily there is a command line command which will recycle individual application pools, which will be quicker than using the IIS administration tool. The command is

C:\windows\System32\inetsrv\appcmd.exe recycle apppool "SharePoint – 80"

Where you replace "SharePoint – 80" with the name of your application pool.

Of course when releasing to a live server you should always go down the proper installation package upgrade, this tip is purely for development purposes on your development server.

There’s a lot more you can do with appcmd – it’s a utility for making configuration changes to IIS so pretty much anything you can do through the IIS MMC snap in can be done via it. There are more details about appcmd on Technet or you can run

C:\windows\System32\inetsrv\appcmd.exe /?

to get help details.

Note: appcmd is for IIS7 not IIS6.

Setting the Owner of Files and Directories in C#

October 21st, 2009 Richard 12 comments

I recently had a requirement to set the owners of users home directories on a Windows server. The .Net framework has built-in support for this so it simply looked like a case of doing this:

IdentityReference owner = new NTAccount("MYDOMAIN\\MyUser");
DirectoryInfo directory = new DirectoryInfo("c:\\myDirectory");
DirectorySecurity directorySecurity = directory.GetAccessControl();

However, when I tried this I just got an InvalidOperationException with the message "The security identifier is not allowed to be the owner of this object".

It turns out that the reason for this is that normally you are only allowed to take ownership yourself, and not assign it. For a user to take ownership they must either have been given the Take Ownership permission or be an administrator.

There is one exception to this rule, and that is if the user has the Restore files and directories privilege then they can assign ownership to other users. Now administrators have this privilege, but by default it is disabled. More details on this from Microsoft.

So to set the owner of the file, you need to have the Restore Files and Directories privilege and then enable it before setting the owner. Really we should also disable the privilege when we’ve finished using it as well.

Unfortunately .Net doesn’t have built in support for this yet, so we are reduced to PInvoking native methods and here’s the code:

sealed class UnmanagedCode
    [DllImport("kernel32.dll", SetLastError=true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool CloseHandle(IntPtr hObject);

    // Use this signature if you do not want the previous state
    [DllImport("advapi32.dll", SetLastError=true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool AdjustTokenPrivileges(IntPtr tokenHandle,
        [MarshalAs(UnmanagedType.Bool)]bool disableAllPrivileges,
        ref TOKEN_PRIVILEGES newState,
        UInt32 bufferLength,
        IntPtr previousState,
        IntPtr returnLength);

    [DllImport("kernel32.dll", ExactSpelling = true)]
    static extern IntPtr GetCurrentProcess();

    [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
    static extern bool OpenProcessToken
        (IntPtr processHandle, int desiredAccess, ref IntPtr phtok);

    [DllImport("advapi32.dll", SetLastError = true)]
    static extern bool LookupPrivilegeValue
            (string host, string name, ref LUID lpLuid);

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public UInt32 PrivilegeCount;
        public LUID Luid;
        public UInt32 Attributes;

    public struct LUID
       public uint LowPart;
       public int HighPart;

    const int SE_PRIVILEGE_ENABLED = 0x00000002;
    const int TOKEN_QUERY = 0x00000008;
    const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
    const string SE_RESTORE_PRIVILEGE = "SeRestorePrivilege"; 

    public static void GiveRestorePrivilege()
        TOKEN_PRIVILEGES tokenPrivileges;
        tokenPrivileges.PrivilegeCount = 1;
        tokenPrivileges.Luid = new LUID();
        tokenPrivileges.Attributes = SE_PRIVILEGE_ENABLED;

        IntPtr tokenHandle = RetrieveProcessToken();

            bool success = LookupPrivilegeValue
                        (null, SE_RESTORE_PRIVILEGE, ref tokenPrivileges.Luid);
            if (success == false)
                int lastError = Marshal.GetLastWin32Error();
                throw new Exception(
                    string.Format("Could not find privilege {0}. Error {1}",
                                        SE_RESTORE_PRIVILEGE, lastError));

            success = AdjustTokenPrivileges(
                                                tokenHandle, false,
                                                ref tokenPrivileges, 0,
                                                IntPtr.Zero, IntPtr.Zero);
            if (success == false)
                int lastError = Marshal.GetLastWin32Error();
                throw new Exception(
                    string.Format("Could not assign privilege {0}. Error {1}",
                                    SE_RESTORE_PRIVILEGE, lastError));


    static IntPtr RetrieveProcessToken()
        IntPtr processHandle = GetCurrentProcess();
        IntPtr tokenHandle = IntPtr.Zero;
        bool success = OpenProcessToken(processHandle,
                                        TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                                        ref tokenHandle);
        if (success == false)
            int lastError = Marshal.GetLastWin32Error();
            throw new Exception(
                string.Format("Could not retrieve process token. Error {0}",
        return tokenHandle;

To remove the privilege you will just need to replace SE_PRIVILEGE_ENABLED with the disabled value. In my use I’m just setting the owner and finishing the process so it’s not really required.

Categories: Development Tags:

How to Mock HttpWebRequest when Unit Testing

October 18th, 2009 Richard 18 comments

One of our latest products interacts with a Restful web service. As this is the core part of its functionality as part of Test Driven Development and Unit Testing I needed to be able to test the calls to the web service using HttpWebRequest.

A quick Google didn’t come up with anything so I started looking at the best way to mock the calls. My initial thought was to extract all use of HttpWebRequest into a separate class, define an interface for setting the request and getting the response and use Dependency Injection to determine whether to use the ‘normal’ class or a mock.

Then I looked a bit closer at WebRequest.Create which is the method you use to create a HttpWebRequest. I noticed that it uses a Factory Method so you could actually register your own factory object depending on the url used. So without any extra code required in the class under test, you can register your factory object and the .Net Framework will automatically use your mocks or stubs. This is pretty cool.

To take advantage of this you need to implement the IWebRequestCreate interface on your factory object, and then register your factory object with WebRequest.RegisterPrefix. What you do in the Create method is up to you, but I created a simple WebRequest and WebResponse pair which store the request for you to test the input, and which returns a configurable response.

First an example of how you can use these:

string response = "my response string here";
WebRequest.RegisterPrefix("test", new TestWebRequestCreate());
TestWebRequest request = TestWebRequestCreate.CreateTestRequest(response);

string url = "test://MyUrl";

ObjectUnderTest myObject = new ObjectUnderTest();
myObject.Url = url;
// DoStuff call the url with a request and then processes the
// response as set above

string requestContent = request.ContentAsString();
Assert.AreEqual(expectedRequestContent, requestContent);

The code for these 3 objects is:

/// <summary>A web request creator for unit testing.</summary>
class TestWebRequestCreate : IWebRequestCreate
    static WebRequest nextRequest;
    static object lockObject = new object();

    static public WebRequest NextRequest
        get { return nextRequest ;}
            lock (lockObject)
                nextRequest = value;

    /// <summary>See <see cref="IWebRequestCreate.Create"/>.</summary>
    public WebRequest Create(Uri uri)
        return nextRequest;

    /// <summary>Utility method for creating a TestWebRequest and setting
    /// it to be the next WebRequest to use.</summary>
    /// <param name="response">The response the TestWebRequest will return.</param>
    public static TestWebRequest CreateTestRequest(string response)
        TestWebRequest request = new TestWebRequest(response);
        NextRequest = request;
        return request;

class TestWebRequest : WebRequest
    MemoryStream requestStream = new MemoryStream();
    MemoryStream responseStream;

    public override string Method { get; set; }
    public override string ContentType { get; set; }
    public override long ContentLength { get; set; }

    /// <summary>Initializes a new instance of <see cref="TestWebRequest"/>
    /// with the response to return.</summary>
    public TestWebRequest(string response)
        responseStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(response));

    /// <summary>Returns the request contents as a string.</summary>
    public string ContentAsString()
        return System.Text.Encoding.UTF8.GetString(requestStream.ToArray());

    /// <summary>See <see cref="WebRequest.GetRequestStream"/>.</summary>
    public override Stream GetRequestStream()
        return requestStream;

    /// <summary>See <see cref="WebRequest.GetResponse"/>.</summary>
    public override WebResponse GetResponse()
        return new TestWebReponse(responseStream);

class TestWebReponse : WebResponse
    Stream responseStream;

    /// <summary>Initializes a new instance of <see cref="TestWebReponse"/>
    /// with the response stream to return.</summary>
    public TestWebReponse(Stream responseStream)
        this.responseStream = responseStream;

    /// <summary>See <see cref="WebResponse.GetResponseStream"/>.</summary>
    public override Stream GetResponseStream()
        return responseStream;

This is quite a simple implementation, just to check the request and return a known response. Once you’ve got this working, you can obviously do more tests such as simulating error conditions.

Categories: Development, Unit Testing Tags:

Memory Leaks in My Planner Web Part

June 12th, 2009 Richard 1 comment

Just spent an evening hunting down and fixing memory leaks in the MLG My Planner web part. The code was opening SPSite and SPWeb objects and then not disposing them. Level 101 error by whoever wrote it!

The layout of the code is a bit bizarre. There’s the main web part project, and 6 other supporting projects, all of which are required by the web part, but not used by another other project. They each only contain 1 or 2 files. This is totally unnecessary and leads to having to ship 6 extra dlls. When I get a bit more time to work on it I’ll have to combine them all into one dll.

My Sql Table Names and Case-Sensitivity

June 9th, 2009 Richard No comments

While implementing the generate quote page for the Learning Gateway Conference I was storing the quote details in a My Sql database. Normally I use Sql Server, but that’s an optional extra on my hosting plan, so I went for MySql which is included, thinking how different can it be. I’d already got had some experience of working with it while integrating with Moodle.

So I had everything up an running nicely on my development server, until I uploaded the code to the live server, then suddenly, bang, the database calls stopped working with the exceptions talking about an invalid query. I finally tracked it down to the case-sensitivity of the table names in MySql. In windows, the table names are case-insensitive, while on Linux the table names are case-sensitive, and my ISP hosts the MySql databases on Linux machines.

The most annoying thing is that I’m normally very careful about case-sensitivity, but didn’t pay attention to it in this specific case. Moral of the story is always be case-sensitive when coding even if you don’t have to be.

Getting SPControls.DateTimeControl to display the local date format

May 29th, 2009 RichardWillis 2 comments

One of the minor problems with SLK was that on the Assignment Properties page the Start and Due dates were always being shown in US format, no matter what the regional setting were. There was a really simple fix, you just need to set the LocaleId of the DateTimeControl and then it will display the date in the regional format of the site.

                spDateTimeStart.LocaleId = SPWeb.Locale.LCID;
                spDateTimeDue.LocaleId = SPWeb.Locale.LCID;

A version with this fix in is now available on the 1.3.2 build page.

Categories: Development, SLK Tags:

Running IIS application pool as a domain user

March 25th, 2009 RichardWillis 1 comment

Just finished setting up an IIS application pool to run as a domain user. There’s a number of hurdles you have to jump over before it will work.

  1. In local policies, set the account to “Act as part of the operating system”. Administrative Tools | Local Security Settings | Local Policies | User Rights Assignments | Act as part of the operating system
  2. In local policies, set the account to log on as a service.
  3. Give the account Modify permissions on the folders uses to create it’s temporary files.
Categories: Development Tags:

SharePoint Manager 2007

March 3rd, 2009 RichardWillis No comments

I’ve just come across a great free tool for SharePoint 2007. It’s SharePoint Manager 2007 and is hosted over at CodePlex. It’s quite simply an object model explorer for SharePoint, allowing you to drill down into any detail of SharePoint, from server properties, to web users even down to individual list items. It will even let you modify the properties if you’re feeling brave.

I’ve lost count of all the little console utilities I’ve written to dump things like list fields, view CAML etc, all of which you can browse to with the tool. I think that it’s going to save me a lot of time and increase my knowledge of SharePoint.

Categories: Development, SharePoint Tags: