I have implemented a custom file upload field type loosely based on the built-in file upload field type to ensure that the file being uploaded is not over a certain size, and also to prevent any files which are uploaded with the same name from being overwritten. However I am currently encountering an issue where whenever one such field is marked as mandatory and the user attempts to submit the form, it is always reported as being invalid even if a file has been selected. I have added breakpoints at the start of the ProcessValue and Validate methods in my field type and neither are being hit when I submit the page, which indicates to me that there is something being run elsewhere after the postback which is marking the field as invalid - it doesn't appear to be something occuring in the Javascript validation. Can anybody advise please?

The site uses Umbraco 4.11.10 with Contour 3.0.21. The production environment is Windows Server 2008 with IIS 7.5 and the development environment is Windows 7 with IIS 7.5 - the issue occurs in both environments.

This is the backend code for my field type:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.UI.WebControls;
using Umbraco.Forms.Core;
using Umbraco.Forms.Core.Controls;

namespace HealthTech.Core.Contour
{
    public class FileUploadWithLimit : FieldType
    {
        private List<object> _value = new List<object>();

        [Umbraco.Forms.Core.Attributes.Setting("Size limit", prevalues = "", description = "Size limit in kilobytes", control = "Umbraco.Forms.Core.FieldSetting.TextField")]
        public string SizeLimitInKbytes { get; set; }

        public FileUploadWithLimit()
        {
            Id = new Guid("0E750295-083B-4CCA-8DC9-13F9974AB5C0");
            Name = "File upload with limit";
            Description = "File upload with limit";
            Icon = "upload.png";
            DataType = FieldDataType.LongString;
        }

        public override List<object> ProcessValue(HttpContextBase httpContext)
        {
            _value.Clear();

            // if a file has previously been submitted, add to values list
            if (AssociatedField.Values.Any())
            {
                var currentFile = AssociatedField.Values.FirstOrDefault();
                _value.Add(currentFile);
            }

            // get reference to this field's post parameter
            var fieldId = AssociatedField.Id.ToString();
            var postedFile = httpContext.Request.Files[fieldId];

            if (postedFile != null)
            {
                if (!string.IsNullOrEmpty(postedFile.FileName) && postedFile.ContentLength > 0)
                {
                    // a file has been submitted

                    // if a file has previously been submitted, clear the values list
                    if (_value.Any()) _value.Clear();

                    // generate path for this session and create directory
                    var sess = httpContext.Session != null ? httpContext.Session.SessionID : "no-session";
                    var dir = String.Format("{0}/files/{1}/{2}/", Configuration.Path, AssociatedField.Form, sess);
                    if (!Directory.Exists(HttpContext.Current.Server.MapPath(dir)))
                    {
                        Directory.CreateDirectory(HttpContext.Current.Server.MapPath(dir));
                    }

                    // ensure filename is unique within directory
                    // try (1)filename.ext, (2)filename.ext... until unique name is found
                    var count = 1;
                    var path = dir + postedFile.FileName;
                    var exists = File.Exists(HttpContext.Current.Server.MapPath(path));
                    while (exists)
                    {
                        path = dir + "(" + count + ")" + postedFile.FileName;
                        exists = File.Exists(HttpContext.Current.Server.MapPath(path));
                        count++;
                    }

                    // save file to disk
                    postedFile.SaveAs(HttpContext.Current.Server.MapPath(path));
                    _value.Add(path);
                }
            }

            return _value;
        }

        public override string RenderPreview()
        {
            return String.Format("<input type=\"file\" /><p>Maximum file size: {0:n0}KB", Convert.ToInt32(SizeLimitInKbytes));
        }

        public override string RenderPreviewWithPrevalues(List<object> prevalues)
        {
            return RenderPreview();
        }

        public override List<Exception> Validate(HttpContextBase httpContext)
        {
            var exceptions = new List<Exception>();
            var fieldId = AssociatedField.Id.ToString();
            var postedFiles = httpContext.Request.Files;

            if (postedFiles.Count > 0)
            {
                var file = postedFiles[fieldId];
                if (file != null && !string.IsNullOrEmpty(file.FileName))
                {
                    int sizeLimit;
                    if (int.TryParse(SizeLimitInKbytes, out sizeLimit))
                    {
                        if (file.ContentLength / 1024 > sizeLimit)
                        {
                            exceptions.Add(
                                new Exception(
                                    String.Format("Submitted file exceeds limit. (Size of {2} is {0:n0}KB, size limit is {1:n0}KB)",
                                    file.ContentLength / 1024,
                                    sizeLimit, 
                                    file.FileName)));
                        }
                    }
                    else
                    {
                        exceptions.Add(
                            new Exception(
                                "Size limit must be an integer"));
                    }
                }
            }

            return exceptions;
        }

        public override bool SupportsRegex
        {
            get
            {
                return false;
            }
        }

        public override bool SupportsPrevalues
        {
            get
            {
                return false;
            }
        }
    }
}