Problem when initializing properties

I keep getting this error: CS0501: 'jQueryUploadTest.Upload.FilesStatus.thumbnail_url.get' must declare a body because it is not marked abstract or extern

I have this exact code outside of my sharepoint project in its own separate website and it works fine. Whenever I try to implement it in my sharepoint project i get that error.

Here is the code for my upload.ashx file:

<%@ WebHandler Language="C#" Class="jQueryUploadTest.Upload" %>

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.AccessControl;
using System.Web;
using System.Web.Script.Serialization;

namespace jQueryUploadTest {

    public class Upload : IHttpHandler {
        public class FilesStatus
        {
            public string thumbnail_url { get; set; }
            public string name { get; set; }
            public string url { get; set; }
            public int size { get; set; }
            public string type { get; set; }
            public string delete_url { get; set; }
            public string delete_type { get; set; }
            public string error { get; set; }
            public string progress { get; set; }
        }
        private readonly JavaScriptSerializer js = new JavaScriptSerializer();
        private string ingestPath;
        public bool IsReusable { get { return false; } }
        public void ProcessRequest (HttpContext context) {
            //var r = context.Response;
            ingestPath = @"C:\temp\ingest\";

            context.Response.AddHeader("Pragma", "no-cache");
            context.Response.AddHeader("Cache-Control", "private, no-cache");

            HandleMethod(context);
        }

        private void HandleMethod (HttpContext context) {
            switch (context.Request.HttpMethod) {
                case "HEAD":
                case "GET":
                    ServeFile(context);
                    break;

                case "POST":
                    UploadFile(context);
                    break;

                case "DELETE":
                    DeleteFile(context);
                    break;

                default:
                    context.Response.ClearHeaders();
                    context.Response.StatusCode = 405;
                    break;
            }
        }

        private void DeleteFile (HttpContext context) {
            string filePath = ingestPath + context.Request["f"];
            if (File.Exists(filePath)) {
                File.Delete(filePath);
            }
        }

        private void UploadFile (HttpContext context) {
            List<FilesStatus> statuses = new List<FilesStatus>();
            System.Collections.Specialized.NameValueCollection headers = context.Request.Headers;

            if (string.IsNullOrEmpty(headers["X-File-Name"])) {
                UploadWholeFile(context, statuses);
            } else {
                UploadPartialFile(headers["X-File-Name"], context, statuses);
            }


            WriteJsonIframeSafe(context, statuses);
        }

        private void UploadPartialFile (string fileName, HttpContext context, List<FilesStatus> statuses) {
            if (context.Request.Files.Count != 1) throw new HttpRequestValidationException("Attempt to upload chunked file containing more than one fragment per request");
            Stream inputStream = context.Request.Files[0].InputStream;
            string fullName = ingestPath + Path.GetFileName(fileName);

            using (FileStream fs = new FileStream(fullName, FileMode.Append, FileAccess.Write)) {
                byte[] buffer = new byte[1024];

                int l = inputStream.Read(buffer, 0, 1024);
                while (l > 0) {
                    fs.Write(buffer,0,l);
                    l = inputStream.Read(buffer, 0, 1024);
                }
                fs.Flush();
                fs.Close();
            }
            FilesStatus MyFileStatus = new FilesStatus();
            MyFileStatus.thumbnail_url = "Thumbnail.ashx?f=" + fileName;
            MyFileStatus.url = "Upload.ashx?f=" + fileName;
            MyFileStatus.name = fileName;
            MyFileStatus.size = (int)(new FileInfo(fullName)).Length;
            MyFileStatus.type = "image/png";
            MyFileStatus.delete_url = "Upload.ashx?f=" + fileName;
            MyFileStatus.delete_type = "DELETE";
            MyFileStatus.progress = "1.0";

          /*  {
                thumbnail_url = "Thumbnail.ashx?f=" + fileName,
                url = "Upload.ashx?f=" + fileName,
                name = fileName,
                size = (int)(new FileInfo(fullName)).Length,
                type = "image/png",
                delete_url = "Upload.ashx?f=" + fileName,
                delete_type = "DELETE",
                progress = "1.0"
            };
            */
            statuses.Add(MyFileStatus);

        }

        private void UploadWholeFile(HttpContext context, List<FilesStatus> statuses) {
            for (int i = 0; i < context.Request.Files.Count; i++) {
                HttpPostedFile file = context.Request.Files[i];
                file.SaveAs(ingestPath + Path.GetFileName(file.FileName));
                string fileName = Path.GetFileName(file.FileName);
                FilesStatus MyFileStatus = new FilesStatus();
                MyFileStatus.thumbnail_url = "Thumbnail.ashx?f=" + fileName;
                MyFileStatus.url = "Upload.ashx?f=" + fileName;
                MyFileStatus.name = fileName;
                MyFileStatus.size = file.ContentLength;
                MyFileStatus.type = "image/png";
                MyFileStatus.delete_url = "Upload.ashx?f=" + fileName;
                MyFileStatus.delete_type = "DELETE";
                MyFileStatus.progress = "1.0";
                statuses.Add(MyFileStatus);
            }
        }

        private void WriteJsonIframeSafe(HttpContext context, List<FilesStatus> statuses) {
            context.Response.AddHeader("Vary", "Accept");
            try {
                if (context.Request["HTTP_ACCEPT"].Contains("application/json")) {
                    context.Response.ContentType = "application/json";
                } else {
                    context.Response.ContentType = "text/plain";
                }
            } catch {
                context.Response.ContentType = "text/plain";
            }

            string jsonObj = js.Serialize(statuses.ToArray());
            context.Response.Write(jsonObj);
        }

        private void ServeFile (HttpContext context) {
            if (string.IsNullOrEmpty(context.Request["f"])) ListCurrentFiles(context);
            else DeliverFile(context);
        }

        private void DeliverFile (HttpContext context) {
            string filePath = ingestPath + context.Request["f"];
            if (File.Exists(filePath)) {
                context.Response.ContentType = "application/octet-stream";
                context.Response.WriteFile(filePath);
                context.Response.AddHeader("Content-Disposition", "attachment, filename=\"" + context.Request["f"] + "\"");
            } else {
                context.Response.StatusCode = 404;
            }
        }

        private void ListCurrentFiles (HttpContext context) {
            List<FilesStatus> files = new List<FilesStatus>();

            string[] names = Directory.GetFiles(@"C:\temp\ingest", "*", SearchOption.TopDirectoryOnly);

            foreach (string name in names) {
                FileInfo f = new FileInfo(name);
                FilesStatus MyFileStatus = new FilesStatus();
                MyFileStatus.thumbnail_url = "Thumbnail.ashx?f=" + f.Name;
                MyFileStatus.url = "Upload.ashx?f=" + f.Name;
                MyFileStatus.name = f.Name;
                MyFileStatus.size = (int)f.Length;
                MyFileStatus.type = "image/png";
                MyFileStatus.delete_url = "Upload.ashx?f=" + f.Name;
                MyFileStatus.delete_type = "DELETE";

                files.Add(MyFileStatus);
                /*files.Add(new FilesStatus
                {
                    thumbnail_url = "Thumbnail.ashx?f=" + f.Name,
                    url = "Upload.ashx?f=" + f.Name,
                    name = f.Name,
                    size = (int)f.Length,
                    type = "image/png",
                    delete_url = "Upload.ashx?f=" + f.Name,
                    delete_type = "DELETE"
                });*/
            }

            context.Response.AddHeader("Content-Disposition", "inline, filename=\"files.json\"");
            string jsonObj = js.Serialize(files.ToArray());
            context.Response.Write(jsonObj开发者_开发问答);
            context.Response.ContentType = "application/json";
        }
    }
}

I have checked my Version targeting and its asp.net 3.5, I went to properties in my project and its 3.5 so I dont think that is the problem.

I just realized what was going on when I spotted this line:

<%@ WebHandler Language="C#" Class="jQueryUploadTest.Upload" %>

You're making a page handle (probably *.ashx) and it is - no doubt - being compiled under ASP.Net 1.1 application pool. This doesn't support C# 3.0 constructs, and thus it fails.

See if you can move the website to an ASP.Net 2.0 application pool. The problem should go away. Be aware that there are - minor - incompatible changes between frameworks 1.1 and 2.0 that might require you to adjust your web.config and minor other details.

I you dont want that, the most straightforward way is to simply don't use the C# 3.0 style construct:

public class FilesStatus
{

    private string m_thumbnail_url;
    private string m_name;
    private string m_url;
    private int m_size;
    private string m_type;
    private string m_delete_url;
    private string m_delete_type;
    private string m_error;
    private string m_progress;

    public string m_thumbnailurl { get { return m_thumbnail_url; } set { m_thumbnail_url = value; } }
    public string name { get { return m_name; } set { m_name = value; } }
    public string url { get { return m_url; } set { m_url = value; } }
    public int size { get { return m_size; } set { m_size = value; } }
    public string type { get { return m_type; } set { m_type = value; } }
    public string m_deleteurl { get { return m_delete_url; } set { m_delete_url = value; } }
    public string m_deletetype { get { return m_delete_type; } set { m_delete_type = value; } }
    public string error { get { return m_error; } set { m_error = value; } }
    public string progress { get { return m_progress; } set { m_progress = value; } }
}

Edit Although a minor possibility, this is probably not it. I suggest you look at my other answer first.

The problem seems to be that your framework version is different for the sharepoint project. See if you can target framework 3.5 or higher.

See documentation:

In C# 3.0 and later, auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors. They also enable client code to create objects. When you declare a property as shown in the following example, the compiler creates a private, anonymous backing field that can only be accessed through the property's get and set accessors.

So this:

 public string thumbnail_url { get; set; }

will only work in an abstract class (with the abstract keyword) or interface (without the public keyword); In C# 3.0+ it will generate an anonymous backing field instead

Update

I just tried to make it plausible that you could be targetting the 3.5 framework, while still using the C# pre-3.0 language specification. I don't have Visual Studio right now, but I used monodevelop:

I can only imagine that Visual Studio has a similar option (hidden) somewhere, and the error message is slightly less helpful