表单数据类 (为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
    }
}