表单数据类 (为WebRequest提供数据)

RequestContent.cs

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;

namespace PortrayUploader
{
    public class RequestContent
    {
        private long _timeTicks;
        private RequestFieldCollection _fields;

        #region Properties
        public long TimeTicks
        {
            get
            {
                return _timeTicks;
            }
            set
            {
                _timeTicks = value;
            }
        }

        public RequestFieldCollection Fields
        {
            get
            {
                if(_fields == null)
                {
                    _fields = new RequestFieldCollection();
                }

                return _fields;
            }
            set
            {
                _fields = value;
            }
        }
        #endregion

        #region RequestContent
        public RequestContent()
        {
        }

        public RequestContent(long timeTicks, RequestFieldCollection fields)
        {
            _timeTicks = timeTicks;
            _fields = fields;
        } 
        #endregion

        #region GetFormData
        public byte[] GetFormData()
        {
            List<byte> buffer = new List<byte>();
            RequestField field;
            byte[] buffer1 = Encoding.Default.GetBytes(string.Format("-----------------------{0:X}/r/n", _timeTicks));

            foreach(RequestField f in _fields)
            {
                buffer.AddRange(buffer1);
                field = f;
                buffer.AddRange(f.GetFormData());
            }

            buffer1 = Encoding.Default.GetBytes(string.Format("-----------------------{0:X}--/r/n", _timeTicks));
            buffer.AddRange(buffer1);
            return buffer.ToArray();
        } 
        #endregion

        #region GetFormUrl
        public byte[] GetFormUrl()
        {
            RequestField field;
            StringBuilder sb = new StringBuilder();

            foreach(RequestField f in _fields)
            {
                field = f;
                sb.Append(f.GetFormUrl());
                sb.Append('&');
            }

            if(sb.Length > 1)
            {
                sb.Remove(sb.Length - 1, 1);
            }

            return Encoding.Default.GetBytes(sb.ToString());
        } 
        #endregion
    }
}

RequestField

using System;
using System.IO;
using System.Text;
using System.Web;

namespace PortrayUploader
{
    public class RequestField
    {
        private bool _isFile;
        private string _name;
        private string _value;

        #region Properties
        public bool IsFile
        {
            get
            {
                return _isFile;
            }
            set
            {
                _isFile = value;
            }
        }

        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }

        public string Value
        {
            get
            {
                return _value;
            }
            set
            {
                _value = value;
            }
        }
        #endregion

        #region RequestField
        public RequestField()
        {
        }

        public RequestField(bool isFile, string name, string value)
        {
            _isFile = isFile;
            _name = name;
            _value = value;
        } 
        #endregion

        #region GetFormData
        public byte[] GetFormData()
        {
            byte[] data;
            byte[] buffer1;
            byte[] buffer2;
            string bufferStr;

            if(IsFile)
            {
                bufferStr = string.Format("Content-Disposition: form-data; name=/"{0}/"; filename=/"{1}/"/r/nContent-Type: application/octet-stream/r/n/r/n", _name, Path.GetFileName(_value));

                using(FileStream fs = new FileStream(_value, FileMode.Open, FileAccess.Read))
                {
                    using(BinaryReader br = new BinaryReader(fs))
                    {
                        buffer2 = br.ReadBytes((int)br.BaseStream.Length);
                    }
                }
            }
            else
            {
                bufferStr = string.Format("Content-Disposition: form-data; name=/"{0}/"", _name);
                buffer2 = Encoding.Default.GetBytes(_value);
            }

            buffer1 = Encoding.Default.GetBytes(bufferStr);
            data = new byte[buffer1.Length + buffer2.Length + 2];
            buffer1.CopyTo(data, 0);
            buffer2.CopyTo(data, buffer1.Length);
            Encoding.Default.GetBytes("/r/n").CopyTo(data, buffer1.Length + buffer2.Length);
            return data;
        } 
        #endregion

        #region GetFormUrl
        public string GetFormUrl()
        {
            return string.Format("{0}={1}", HttpUtility.UrlEncode(_name), HttpUtility.UrlEncode(_value));
        } 
        #endregion
    }
}

RequestFieldCollection.cs

using System;
using System.Collections;
using System.Text;

namespace PortrayUploader
{
    public class RequestFieldCollection : IList, ICollection, IEnumerable
    {
        private ArrayList requestFields;

        public RequestFieldCollection()
        {
            this.requestFields = new ArrayList();
        }

        #region IList 成员

        #region Add
        public void Add(bool isFile, string name, string value)
        {
            this.Add(new RequestField(isFile, name, value));
        }

        public void Add(RequestField field)
        {
            this.requestFields.Add(field);
        } 
        #endregion

        #region AddRange
        public void AddRange(RequestField[] fields)
        {
            if(fields == null)
            {
                throw new ArgumentException("fields");
            }

            foreach(RequestField field in fields)
            {
                this.Add(field);
            }
        } 
        #endregion

        #region Clear
        public void Clear()
        {
            this.requestFields.Clear();
        } 
        #endregion

        #region Contains
        public bool Contains(RequestField field)
        {
            return this.requestFields.Contains(field);
        } 
        #endregion

        #region IndexOf
        public int IndexOf(RequestField field)
        {
            return this.requestFields.IndexOf(field);
        } 
        #endregion

        #region Insert
        public void Insert(int index, RequestField field)
        {
            this.requestFields.Insert(index, field);
        } 
        #endregion

        #region InsertRange
        public void InsertRange(int index, RequestField[] fields)
        {
            if(fields == null)
            {
                throw new ArgumentException("fields");
            }

            foreach(RequestField field in fields)
            {
                this.Insert(index, field);
            }
        } 
        #endregion

        #region IsFixedSize
        public bool IsFixedSize
        {
            get
            {
                return this.requestFields.IsFixedSize;
            }
        } 
        #endregion

        #region IsReadOnly
        public bool IsReadOnly
        {
            get
            {
                return this.requestFields.IsReadOnly;
            }
        } 
        #endregion

        #region Remove
        public void Remove(RequestField field)
        {
            this.requestFields.Remove(field);
        } 
        #endregion

        #region RemoveAt
        public void RemoveAt(int index)
        {
            this.requestFields.RemoveAt(index);
        } 
        #endregion

        #region RequestField[]
        public RequestField this[int index]
        {
            get
            {
                return (RequestField)this.requestFields[index];
            }
            set
            {
                this.requestFields[index] = (RequestField)value;
            }
        }

        public RequestField this[string name]
        {
            get
            {
                int index = this.FindByName(name);

                if(index >= 0)
                {
                    return this[index];
                }

                return null;
            }
            set
            {
                if(name == null)
                {
                    throw new ArgumentNullException("name");
                }

                int index = this.FindByName(name);

                if(index >= 0)
                {
                    this[index] = (RequestField)value;
                }
                else
                {
                    this.Add((RequestField)value);
                }
            }
        }
        #endregion

        #region internal RequestField
        internal int FindByName(string name)
        {
            foreach(RequestField field in this.requestFields)
            {
                if(field.Name == name)
                {
                    return this.IndexOf(field);
                }
            }

            return -1;
        } 
        #endregion

        #endregion

        #region ICollection 成员

        #region CopyTo
        void ICollection.CopyTo(Array array, int index)
        {
            this.requestFields.CopyTo(array, index);
        } 
        #endregion

        #region Count
        int ICollection.Count
        {
            get
            {
                return this.requestFields.Count;
            }
        } 
        #endregion

        #region IsSynchronized
        bool ICollection.IsSynchronized
        {
            get
            {
                return this.requestFields.IsSynchronized;
            }
        } 
        #endregion

        #region SyncRoot
        object ICollection.SyncRoot
        {
            get
            {
                return this.requestFields.SyncRoot;
            }
        } 
        #endregion

        #endregion

        #region IEnumerable 成员

        #region GetEnumerator
        public IEnumerator GetEnumerator()
        {
            return this.requestFields.GetEnumerator();
        } 
        #endregion

        #endregion

        #region IList Members

        int IList.Add(object field)
        {
            return this.requestFields.Add((RequestField)field);
        }

        bool IList.Contains(object field)
        {
            return this.Contains((RequestField)field);
        }

        int IList.IndexOf(object field)
        {
            return this.IndexOf((RequestField)field);
        }

        void IList.Insert(int index, object field)
        {
            this.Insert(index, (RequestField)field);
        }

        bool IList.IsFixedSize
        {
            get
            {
                return this.IsFixedSize;
            }
        }

        bool IList.IsReadOnly
        {
            get
            {
                return this.IsReadOnly;
            }
        }

        void IList.Remove(object field)
        {
            this.Remove((RequestField)field);
        }

        void IList.RemoveAt(int index)
        {
            this.RemoveAt(index);
        }

        object IList.this[int index]
        {
            get
            {
                return this[index];
            }
            set
            {
                this[index] = (RequestField)value;
            }
        }

        #endregion
    }
}