チェンジセット 1639 (default)


以下の違いを無視:
日時:
2024/02/14 3:25:54 (8ヵ月前)
更新者:
hizuya@…
ログメッセージ:
  • アップロードされたファイルを保持する機能を追加。
場所:
framework/trunk
ファイル:
6個の更新

凡例:

未変更
追加
削除

  • framework/trunk/WebApplication/UI/WebControls/FileUploadPage.aspx

    r1637 r1639  
    2525            </div> 
    2626            <div> 
     27                <asp:Button runat="server" Text="Button101"/> 
    2728                <sff:FileUpload ID="FileUpload101" runat="server" 
    2829                    OnFileSelected="FileUpload101_OnFileSelected" /> 
    29                 <asp:Button runat="server" Text="Button101"/> 
    3030            </div> 
    3131 
    … …  
    7878            </div> 
    7979 
     80 
     81            <h2>アップロードファイルキャッシュ</h2> 
     82 
     83            <h3>キャッシュ無し</h3> 
     84            <div> 
     85                Page.Load<asp:Literal runat="server" ID="Literal3011"/> 
     86            </div> 
     87            <div> 
     88                Button.Click<asp:Literal runat="server" ID="Literal3012"/> 
     89            </div> 
     90            <div> 
     91                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal3013"/> 
     92            </div> 
     93            <div> 
     94                <asp:Button runat="server" ID="Button301" 
     95                    Text="Button301" 
     96                    OnClick="Button301_OnClick"/> 
     97                <sff:FileUpload ID="FileUpload301" runat="server" 
     98                    Accept="text/plain" 
     99                    CachePostedFile="False" 
     100                    OnFileSelected="FileUpload301_OnFileSelected" /> 
     101            </div> 
     102 
     103            <h3>キャッシュ有り</h3> 
     104            <div> 
     105                Page.Load<asp:Literal runat="server" ID="Literal3021"/> 
     106            </div> 
     107            <div> 
     108                Button.Click<asp:Literal runat="server" ID="Literal3022"/> 
     109            </div> 
     110            <div> 
     111                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal3023"/> 
     112            </div> 
     113            <div> 
     114                <asp:Button runat="server" ID="Button302" 
     115                    Text="Button302" 
     116                    OnClick="Button302_OnClick"/> 
     117                <sff:FileUpload ID="FileUpload302" runat="server" 
     118                    Accept="text/plain" 
     119                    CachePostedFile="True" 
     120                    OnFileSelected="FileUpload302_OnFileSelected" /> 
     121            </div> 
     122 
     123            <h3>キャッシュ有り + leaveOpen</h3> 
     124            <div> 
     125                Page.Load<asp:Literal runat="server" ID="Literal3031"/> 
     126            </div> 
     127            <div> 
     128                Button.Click<asp:Literal runat="server" ID="Literal3032"/> 
     129            </div> 
     130            <div> 
     131                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal3033"/> 
     132            </div> 
     133            <div> 
     134                <asp:Button runat="server" ID="Button303" 
     135                    Text="Button303" 
     136                    OnClick="Button303_OnClick"/> 
     137                <sff:FileUpload ID="FileUpload303" runat="server" 
     138                    Accept="text/plain" 
     139                    CachePostedFile="True" 
     140                    OnFileSelected="FileUpload303_OnFileSelected" /> 
     141            </div> 
     142 
     143 
     144            <h2>アップロードファイルキャッシュ + AllowMultiple</h2> 
     145 
     146            <h3>キャッシュ無し</h3> 
     147            <div> 
     148                Page.Load<asp:Literal runat="server" ID="Literal4011"/> 
     149            </div> 
     150            <div> 
     151                Button.Click<asp:Literal runat="server" ID="Literal4012"/> 
     152            </div> 
     153            <div> 
     154                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal4013"/> 
     155            </div> 
     156            <div> 
     157                <asp:Button runat="server" ID="Button401" 
     158                    Text="Button401" 
     159                    OnClick="Button401_OnClick"/> 
     160                <sff:FileUpload ID="FileUpload401" runat="server" 
     161                    Accept="text/plain" 
     162                    CachePostedFile="False" 
     163                    AllowMultiple="True" 
     164                    OnFileSelected="FileUpload401_OnFileSelected" /> 
     165            </div> 
     166 
     167            <h3>キャッシュ有り</h3> 
     168            <div> 
     169                Page.Load<asp:Literal runat="server" ID="Literal4021"/> 
     170            </div> 
     171            <div> 
     172                Button.Click<asp:Literal runat="server" ID="Literal4022"/> 
     173            </div> 
     174            <div> 
     175                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal4023"/> 
     176            </div> 
     177            <div> 
     178                <asp:Button runat="server" ID="Button402" 
     179                    Text="Button402" 
     180                    OnClick="Button402_OnClick"/> 
     181                <sff:FileUpload ID="FileUpload402" runat="server" 
     182                    Accept="text/plain" 
     183                    CachePostedFile="True" 
     184                    AllowMultiple="True" 
     185                    OnFileSelected="FileUpload402_OnFileSelected" /> 
     186            </div> 
     187 
     188            <h3>キャッシュ有り + leaveOpen</h3> 
     189            <div> 
     190                Page.Load<asp:Literal runat="server" ID="Literal4031"/> 
     191            </div> 
     192            <div> 
     193                Button.Click<asp:Literal runat="server" ID="Literal4032"/> 
     194            </div> 
     195            <div> 
     196                FileUpload.FileSelected<asp:Literal runat="server" ID="Literal4033"/> 
     197            </div> 
     198            <div> 
     199                <asp:Button runat="server" ID="Button403" 
     200                    Text="Button403" 
     201                    OnClick="Button403_OnClick"/> 
     202                <sff:FileUpload ID="FileUpload403" runat="server" 
     203                    Accept="text/plain" 
     204                    CachePostedFile="True" 
     205                    AllowMultiple="True" 
     206                    OnFileSelected="FileUpload403_OnFileSelected" /> 
     207            </div> 
     208 
     209 
     210            <h2>asp:UploadFile</h2> 
     211 
     212            <h3>通常</h3> 
     213            <div> 
     214                Page.Load<asp:Literal runat="server" ID="Literal9011"/> 
     215            </div> 
     216            <div> 
     217                Button.Click<asp:Literal runat="server" ID="Literal9012"/> 
     218            </div> 
     219            <div> 
     220                <asp:Button runat="server" ID="Button901" 
     221                    Text="Button901" 
     222                    OnClick="Button901_OnClick"/> 
     223                <asp:FileUpload ID="FileUpload901" runat="server" 
     224                    Accept="text/plain" /> 
     225            </div> 
     226 
     227            <h3>AllowMultiple</h3> 
     228            <div> 
     229                Page.Load<asp:Literal runat="server" ID="Literal9021"/> 
     230            </div> 
     231            <div> 
     232                Button.Click<asp:Literal runat="server" ID="Literal9022"/> 
     233            </div> 
     234            <div> 
     235                <asp:Button runat="server" ID="Button902" 
     236                    Text="Button902" 
     237                    OnClick="Button902_OnClick"/> 
     238                <asp:FileUpload ID="FileUpload902" runat="server" 
     239                    Accept="text/plain" 
     240                    AllowMultiple="True" /> 
     241            </div> 
     242 
    80243        </div> 
    81244    </form> 

  • framework/trunk/WebApplication/UI/WebControls/FileUploadPage.aspx.cs

    r1635 r1639  
    2424{ 
    2525    using System; 
     26    using System.Collections.Generic; 
     27    using System.IO; 
     28    using System.Text; 
    2629    using System.Web; 
    2730 
    … …  
    3437    { 
    3538        /// <summary> 
     39        /// ポストバックの回数。 
     40        /// </summary> 
     41        [ViewStateMember] 
     42        private int counter; 
     43 
     44 
     45        /// <summary> 
    3646        /// インスタンスを作成します。 
    3747        /// </summary> 
    3848        public FileUploadPage() 
    3949        { 
    40             // AVOID 
    41         } 
    42  
     50            Load += Page_OnLoad; 
     51        } 
     52 
     53        /// <summary> 
     54        /// <see cref="System.Web.UI.Control.Load"/> イベントハンドラです。 
     55        /// </summary> 
     56        /// <param name="sender">イベントのソース。</param> 
     57        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     58        protected void Page_OnLoad(object sender, EventArgs e) 
     59        { 
     60            counter++; 
     61 
     62            Literal3011.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload301); 
     63            Literal3021.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload302); 
     64            Literal3031.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload303, true); 
     65            Literal4011.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload401); 
     66            Literal4021.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload402); 
     67            Literal4031.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload403, true); 
     68            Literal9011.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload901); 
     69            Literal9021.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload902); 
     70        } 
    4371 
    4472        /// <summary> 
    … …  
    72100        } 
    73101 
     102        /// <summary> 
     103        /// <see cref="Button301"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     104        /// </summary> 
     105        /// <param name="sender">イベントのソース。</param> 
     106        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     107        protected void Button301_OnClick(object sender, EventArgs e) 
     108        { 
     109            Literal3012.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload301); 
     110        } 
     111 
     112        /// <summary> 
     113        /// <see cref="FileUpload301"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     114        /// </summary> 
     115        /// <param name="sender">イベントのソース。</param> 
     116        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     117        protected void FileUpload301_OnFileSelected(object sender, EventArgs e) 
     118        { 
     119            Literal3013.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload301); 
     120        } 
     121 
     122        /// <summary> 
     123        /// <see cref="Button302"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     124        /// </summary> 
     125        /// <param name="sender">イベントのソース。</param> 
     126        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     127        protected void Button302_OnClick(object sender, EventArgs e) 
     128        { 
     129            Literal3022.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload302); 
     130        } 
     131 
     132        /// <summary> 
     133        /// <see cref="FileUpload302"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     134        /// </summary> 
     135        /// <param name="sender">イベントのソース。</param> 
     136        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     137        protected void FileUpload302_OnFileSelected(object sender, EventArgs e) 
     138        { 
     139            Literal3023.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload302); 
     140        } 
     141 
     142        /// <summary> 
     143        /// <see cref="Button303"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     144        /// </summary> 
     145        /// <param name="sender">イベントのソース。</param> 
     146        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     147        protected void Button303_OnClick(object sender, EventArgs e) 
     148        { 
     149            Literal3032.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload303, true); 
     150        } 
     151 
     152        /// <summary> 
     153        /// <see cref="FileUpload303"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     154        /// </summary> 
     155        /// <param name="sender">イベントのソース。</param> 
     156        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     157        protected void FileUpload303_OnFileSelected(object sender, EventArgs e) 
     158        { 
     159            Literal3033.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload303, true); 
     160        } 
     161 
     162 
     163        /// <summary> 
     164        /// <see cref="Button401"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     165        /// </summary> 
     166        /// <param name="sender">イベントのソース。</param> 
     167        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     168        protected void Button401_OnClick(object sender, EventArgs e) 
     169        { 
     170            Literal4012.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload401); 
     171        } 
     172 
     173        /// <summary> 
     174        /// <see cref="FileUpload401"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     175        /// </summary> 
     176        /// <param name="sender">イベントのソース。</param> 
     177        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     178        protected void FileUpload401_OnFileSelected(object sender, EventArgs e) 
     179        { 
     180            Literal4013.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload401); 
     181        } 
     182 
     183        /// <summary> 
     184        /// <see cref="Button402"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     185        /// </summary> 
     186        /// <param name="sender">イベントのソース。</param> 
     187        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     188        protected void Button402_OnClick(object sender, EventArgs e) 
     189        { 
     190            Literal4022.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload402); 
     191        } 
     192 
     193        /// <summary> 
     194        /// <see cref="FileUpload402"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     195        /// </summary> 
     196        /// <param name="sender">イベントのソース。</param> 
     197        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     198        protected void FileUpload402_OnFileSelected(object sender, EventArgs e) 
     199        { 
     200            Literal4023.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload402); 
     201        } 
     202 
     203        /// <summary> 
     204        /// <see cref="Button403"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     205        /// </summary> 
     206        /// <param name="sender">イベントのソース。</param> 
     207        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     208        protected void Button403_OnClick(object sender, EventArgs e) 
     209        { 
     210            Literal4032.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload403, true); 
     211        } 
     212 
     213        /// <summary> 
     214        /// <see cref="FileUpload403"/> の <see cref="FileUpload.FileSelected"/> イベントハンドラです。 
     215        /// </summary> 
     216        /// <param name="sender">イベントのソース。</param> 
     217        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     218        protected void FileUpload403_OnFileSelected(object sender, EventArgs e) 
     219        { 
     220            Literal4033.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload403, true); 
     221        } 
     222 
     223 
     224        /// <summary> 
     225        /// <see cref="Button901"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     226        /// </summary> 
     227        /// <param name="sender">イベントのソース。</param> 
     228        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     229        protected void Button901_OnClick(object sender, EventArgs e) 
     230        { 
     231            Literal9012.Text = "[" + counter + "]: " + GetPostedFileInformation(FileUpload901); 
     232        } 
     233 
     234        /// <summary> 
     235        /// <see cref="Button902"/> の <see cref="System.Web.UI.WebControls.Button.Click"/> イベントハンドラです。 
     236        /// </summary> 
     237        /// <param name="sender">イベントのソース。</param> 
     238        /// <param name="e">イベント データを格納している <see cref="EventArgs"/>。</param> 
     239        protected void Button902_OnClick(object sender, EventArgs e) 
     240        { 
     241            Literal9022.Text = "[" + counter + "]: " + GetPostedFilesInformation(FileUpload902); 
     242        } 
     243 
    74244 
    75245        /// <summary> 
    76246        /// ポストされたファイルの情報を取得します。 
    77247        /// </summary> 
     248        /// <param name="fileUpload"><see cref="System.Web.UI.WebControls.FileUpload"/> コントロール。</param> 
     249        /// <returns> 
     250        /// ポストされたファイルの情報を表す文字列。 
     251        /// </returns> 
     252        private static string GetPostedFileInformation(System.Web.UI.WebControls.FileUpload fileUpload) 
     253        { 
     254            return GetPostedFileInformation(fileUpload, false); 
     255        } 
     256 
     257        /// <summary> 
     258        /// ポストされたファイルの情報を取得します。 
     259        /// </summary> 
     260        /// <param name="fileUpload"><see cref="System.Web.UI.WebControls.FileUpload"/> コントロール。</param> 
     261        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     262        /// <returns> 
     263        /// ポストされたファイルの情報を表す文字列。 
     264        /// </returns> 
     265        private static string GetPostedFileInformation(System.Web.UI.WebControls.FileUpload fileUpload, bool leaveOpen) 
     266        { 
     267            return GetPostedFileInformation(fileUpload.HasFile, fileUpload.PostedFile, leaveOpen); 
     268        } 
     269 
     270 
     271        /// <summary> 
     272        /// ポストされたファイルの情報を取得します。 
     273        /// </summary> 
    78274        /// <param name="fileUpload"><see cref="FileUpload"/> コントロール。</param> 
    79275        /// <returns> 
    … …  
    82278        private static string GetPostedFileInformation(FileUpload fileUpload) 
    83279        { 
    84             HttpPostedFile postedFile = fileUpload.PostedFile; 
    85             if (postedFile == null || string.IsNullOrEmpty(postedFile.FileName)) 
    86             { 
    87                 return "(none)"; 
    88             } 
    89  
    90             return postedFile.FileName 
     280            return GetPostedFileInformation(fileUpload, false); 
     281        } 
     282 
     283        /// <summary> 
     284        /// ポストされたファイルの情報を取得します。 
     285        /// </summary> 
     286        /// <param name="fileUpload"><see cref="FileUpload"/> コントロール。</param> 
     287        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     288        /// <returns> 
     289        /// ポストされたファイルの情報を表す文字列。 
     290        /// </returns> 
     291        private static string GetPostedFileInformation(FileUpload fileUpload, bool leaveOpen) 
     292        { 
     293            return GetPostedFileInformation(fileUpload.HasFile, fileUpload.PostedFile, leaveOpen); 
     294        } 
     295 
     296 
     297        /// <summary> 
     298        /// ポストされたファイルの情報を取得します。 
     299        /// </summary> 
     300        /// <param name="hasFile">ファイルが有るかどうか。</param> 
     301        /// <param name="postedFile"><see cref="HttpPostedFile"/> コントロール。</param> 
     302        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     303        /// <returns> 
     304        /// ポストされたファイルの情報を表す文字列。 
     305        /// </returns> 
     306        private static string GetPostedFileInformation(bool hasFile, HttpPostedFile postedFile, bool leaveOpen) 
     307        { 
     308            if (postedFile == null) 
     309            { 
     310                return !hasFile ? "NO FILE" : "(null !?)"; 
     311            } 
     312 
     313            return (hasFile ? string.Empty : "NO FILE, ") 
     314                + "name=" + postedFile.FileName 
    91315                + ", length=" + postedFile.ContentLength 
    92                 + ", type=" + postedFile.ContentType; 
     316                + ", type=" + postedFile.ContentType 
     317                + (postedFile.ContentType == "text/plain" 
     318                    ? ", contents={" + GetContents(postedFile, leaveOpen) + "}" 
     319                    : string.Empty); 
     320        } 
     321 
     322 
     323 
     324        /// <summary> 
     325        /// ポストされたファイルコレクションの情報を取得します。 
     326        /// </summary> 
     327        /// <param name="fileUpload"><see cref="System.Web.UI.WebControls.FileUpload"/> コントロール。</param> 
     328        /// <returns> 
     329        /// ポストされたファイルコレクションの情報を表す文字列。 
     330        /// </returns> 
     331        private static string GetPostedFilesInformation(System.Web.UI.WebControls.FileUpload fileUpload) 
     332        { 
     333            return GetPostedFilesInformation(fileUpload, false); 
     334        } 
     335 
     336        /// <summary> 
     337        /// ポストされたファイルコレクションの情報を取得します。 
     338        /// </summary> 
     339        /// <param name="fileUpload"><see cref="System.Web.UI.WebControls.FileUpload"/> コントロール。</param> 
     340        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     341        /// <returns> 
     342        /// ポストされたファイルコレクションの情報を表す文字列。 
     343        /// </returns> 
     344        private static string GetPostedFilesInformation(System.Web.UI.WebControls.FileUpload fileUpload, bool leaveOpen) 
     345        { 
     346            return GetPostedFilesInformation(fileUpload.HasFiles, fileUpload.PostedFiles, leaveOpen); 
     347        } 
     348 
     349 
     350        /// <summary> 
     351        /// ポストされたファイルコレクションの情報を取得します。 
     352        /// </summary> 
     353        /// <param name="fileUpload"><see cref="FileUpload"/> コントロール。</param> 
     354        /// <returns> 
     355        /// ポストされたファイルコレクションの情報を表す文字列。 
     356        /// </returns> 
     357        private static string GetPostedFilesInformation(FileUpload fileUpload) 
     358        { 
     359            return GetPostedFilesInformation(fileUpload, false); 
     360        } 
     361 
     362        /// <summary> 
     363        /// ポストされたファイルコレクションの情報を取得します。 
     364        /// </summary> 
     365        /// <param name="fileUpload"><see cref="FileUpload"/> コントロール。</param> 
     366        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     367        /// <returns> 
     368        /// ポストされたファイルコレクションの情報を表す文字列。 
     369        /// </returns> 
     370        private static string GetPostedFilesInformation(FileUpload fileUpload, bool leaveOpen) 
     371        { 
     372            return GetPostedFilesInformation(fileUpload.HasFiles, fileUpload.PostedFiles, leaveOpen); 
     373        } 
     374 
     375 
     376        /// <summary> 
     377        /// ポストされたファイルコレクションの情報を取得します。 
     378        /// </summary> 
     379        /// <param name="hasFiles">ファイルが有るかどうか。</param> 
     380        /// <param name="postedFiles"><see cref="HttpPostedFile"/> のリスト。</param> 
     381        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     382        /// <returns> 
     383        /// ポストされたファイルコレクションの情報を表す文字列。 
     384        /// </returns> 
     385        private static string GetPostedFilesInformation(bool hasFiles, IList<HttpPostedFile> postedFiles, bool leaveOpen) 
     386        { 
     387            if (postedFiles == null) 
     388            { 
     389                return !hasFiles ? "NO FILEs + null" : "(null !?)"; 
     390            } 
     391 
     392            StringBuilder builder = new StringBuilder(); 
     393 
     394            if (!hasFiles) 
     395            { 
     396                builder.Append("NO FILEs"); 
     397            } 
     398            else if (postedFiles.Count == 0) 
     399            { 
     400                return "EMPTY"; 
     401            } 
     402 
     403            foreach (HttpPostedFile postedFile in postedFiles) 
     404            { 
     405                if (builder.Length > 0) 
     406                { 
     407                    builder.Append(", "); 
     408                } 
     409 
     410                builder.Append("[name="); 
     411                builder.Append(postedFile.FileName); 
     412                builder.Append(", length="); 
     413                builder.Append(postedFile.ContentLength); 
     414                builder.Append(", type="); 
     415                builder.Append(postedFile.ContentType); 
     416 
     417                if (postedFile.ContentType == "text/plain") 
     418                { 
     419                    builder.Append(", contents={"); 
     420                    builder.Append(GetContents(postedFile, leaveOpen)); 
     421                    builder.Append("}"); 
     422                } 
     423 
     424                builder.Append("]"); 
     425            } 
     426 
     427            return builder.ToString(); 
     428        } 
     429 
     430 
     431        /// <summary> 
     432        /// 内容を文字列で返します。 
     433        /// </summary> 
     434        /// <param name="postedFile"><see cref="HttpPostedFile"/>。</param> 
     435        /// <param name="leaveOpen">ストリームを開いたままにする場合は <see langword="true"/>。</param> 
     436        /// <returns> 
     437        /// ファイルの内容。 
     438        /// </returns> 
     439        private static string GetContents(HttpPostedFile postedFile, bool leaveOpen) 
     440        { 
     441            if (leaveOpen) 
     442            { 
     443                postedFile.InputStream.Seek(0, SeekOrigin.Begin); 
     444            } 
     445 
     446            using (StreamReader reader 
     447                = new StreamReader( 
     448                    postedFile.InputStream, 
     449                    Encoding.Default, 
     450                    true, 
     451                    0x100, 
     452                    leaveOpen)) 
     453            { 
     454                return reader.ReadToEnd(); 
     455            } 
    93456        } 
    94457    } 

  • framework/trunk/WebApplication/UI/WebControls/FileUploadPage.aspx.designer.cs

    r1637 r1639  
    9393        /// </remarks> 
    9494        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload202; 
     95         
     96        /// <summary> 
     97        /// Literal3011 コントロール。 
     98        /// </summary> 
     99        /// <remarks> 
     100        /// 自動生成されたフィールド。 
     101        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     102        /// </remarks> 
     103        protected global::System.Web.UI.WebControls.Literal Literal3011; 
     104         
     105        /// <summary> 
     106        /// Literal3012 コントロール。 
     107        /// </summary> 
     108        /// <remarks> 
     109        /// 自動生成されたフィールド。 
     110        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     111        /// </remarks> 
     112        protected global::System.Web.UI.WebControls.Literal Literal3012; 
     113         
     114        /// <summary> 
     115        /// Literal3013 コントロール。 
     116        /// </summary> 
     117        /// <remarks> 
     118        /// 自動生成されたフィールド。 
     119        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     120        /// </remarks> 
     121        protected global::System.Web.UI.WebControls.Literal Literal3013; 
     122         
     123        /// <summary> 
     124        /// Button301 コントロール。 
     125        /// </summary> 
     126        /// <remarks> 
     127        /// 自動生成されたフィールド。 
     128        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     129        /// </remarks> 
     130        protected global::System.Web.UI.WebControls.Button Button301; 
     131         
     132        /// <summary> 
     133        /// FileUpload301 コントロール。 
     134        /// </summary> 
     135        /// <remarks> 
     136        /// 自動生成されたフィールド。 
     137        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     138        /// </remarks> 
     139        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload301; 
     140         
     141        /// <summary> 
     142        /// Literal3021 コントロール。 
     143        /// </summary> 
     144        /// <remarks> 
     145        /// 自動生成されたフィールド。 
     146        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     147        /// </remarks> 
     148        protected global::System.Web.UI.WebControls.Literal Literal3021; 
     149         
     150        /// <summary> 
     151        /// Literal3022 コントロール。 
     152        /// </summary> 
     153        /// <remarks> 
     154        /// 自動生成されたフィールド。 
     155        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     156        /// </remarks> 
     157        protected global::System.Web.UI.WebControls.Literal Literal3022; 
     158         
     159        /// <summary> 
     160        /// Literal3023 コントロール。 
     161        /// </summary> 
     162        /// <remarks> 
     163        /// 自動生成されたフィールド。 
     164        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     165        /// </remarks> 
     166        protected global::System.Web.UI.WebControls.Literal Literal3023; 
     167         
     168        /// <summary> 
     169        /// Button302 コントロール。 
     170        /// </summary> 
     171        /// <remarks> 
     172        /// 自動生成されたフィールド。 
     173        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     174        /// </remarks> 
     175        protected global::System.Web.UI.WebControls.Button Button302; 
     176         
     177        /// <summary> 
     178        /// FileUpload302 コントロール。 
     179        /// </summary> 
     180        /// <remarks> 
     181        /// 自動生成されたフィールド。 
     182        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     183        /// </remarks> 
     184        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload302; 
     185         
     186        /// <summary> 
     187        /// Literal3031 コントロール。 
     188        /// </summary> 
     189        /// <remarks> 
     190        /// 自動生成されたフィールド。 
     191        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     192        /// </remarks> 
     193        protected global::System.Web.UI.WebControls.Literal Literal3031; 
     194         
     195        /// <summary> 
     196        /// Literal3032 コントロール。 
     197        /// </summary> 
     198        /// <remarks> 
     199        /// 自動生成されたフィールド。 
     200        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     201        /// </remarks> 
     202        protected global::System.Web.UI.WebControls.Literal Literal3032; 
     203         
     204        /// <summary> 
     205        /// Literal3033 コントロール。 
     206        /// </summary> 
     207        /// <remarks> 
     208        /// 自動生成されたフィールド。 
     209        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     210        /// </remarks> 
     211        protected global::System.Web.UI.WebControls.Literal Literal3033; 
     212         
     213        /// <summary> 
     214        /// Button303 コントロール。 
     215        /// </summary> 
     216        /// <remarks> 
     217        /// 自動生成されたフィールド。 
     218        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     219        /// </remarks> 
     220        protected global::System.Web.UI.WebControls.Button Button303; 
     221         
     222        /// <summary> 
     223        /// FileUpload303 コントロール。 
     224        /// </summary> 
     225        /// <remarks> 
     226        /// 自動生成されたフィールド。 
     227        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     228        /// </remarks> 
     229        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload303; 
     230         
     231        /// <summary> 
     232        /// Literal4011 コントロール。 
     233        /// </summary> 
     234        /// <remarks> 
     235        /// 自動生成されたフィールド。 
     236        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     237        /// </remarks> 
     238        protected global::System.Web.UI.WebControls.Literal Literal4011; 
     239         
     240        /// <summary> 
     241        /// Literal4012 コントロール。 
     242        /// </summary> 
     243        /// <remarks> 
     244        /// 自動生成されたフィールド。 
     245        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     246        /// </remarks> 
     247        protected global::System.Web.UI.WebControls.Literal Literal4012; 
     248         
     249        /// <summary> 
     250        /// Literal4013 コントロール。 
     251        /// </summary> 
     252        /// <remarks> 
     253        /// 自動生成されたフィールド。 
     254        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     255        /// </remarks> 
     256        protected global::System.Web.UI.WebControls.Literal Literal4013; 
     257         
     258        /// <summary> 
     259        /// Button401 コントロール。 
     260        /// </summary> 
     261        /// <remarks> 
     262        /// 自動生成されたフィールド。 
     263        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     264        /// </remarks> 
     265        protected global::System.Web.UI.WebControls.Button Button401; 
     266         
     267        /// <summary> 
     268        /// FileUpload401 コントロール。 
     269        /// </summary> 
     270        /// <remarks> 
     271        /// 自動生成されたフィールド。 
     272        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     273        /// </remarks> 
     274        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload401; 
     275         
     276        /// <summary> 
     277        /// Literal4021 コントロール。 
     278        /// </summary> 
     279        /// <remarks> 
     280        /// 自動生成されたフィールド。 
     281        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     282        /// </remarks> 
     283        protected global::System.Web.UI.WebControls.Literal Literal4021; 
     284         
     285        /// <summary> 
     286        /// Literal4022 コントロール。 
     287        /// </summary> 
     288        /// <remarks> 
     289        /// 自動生成されたフィールド。 
     290        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     291        /// </remarks> 
     292        protected global::System.Web.UI.WebControls.Literal Literal4022; 
     293         
     294        /// <summary> 
     295        /// Literal4023 コントロール。 
     296        /// </summary> 
     297        /// <remarks> 
     298        /// 自動生成されたフィールド。 
     299        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     300        /// </remarks> 
     301        protected global::System.Web.UI.WebControls.Literal Literal4023; 
     302         
     303        /// <summary> 
     304        /// Button402 コントロール。 
     305        /// </summary> 
     306        /// <remarks> 
     307        /// 自動生成されたフィールド。 
     308        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     309        /// </remarks> 
     310        protected global::System.Web.UI.WebControls.Button Button402; 
     311         
     312        /// <summary> 
     313        /// FileUpload402 コントロール。 
     314        /// </summary> 
     315        /// <remarks> 
     316        /// 自動生成されたフィールド。 
     317        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     318        /// </remarks> 
     319        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload402; 
     320         
     321        /// <summary> 
     322        /// Literal4031 コントロール。 
     323        /// </summary> 
     324        /// <remarks> 
     325        /// 自動生成されたフィールド。 
     326        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     327        /// </remarks> 
     328        protected global::System.Web.UI.WebControls.Literal Literal4031; 
     329         
     330        /// <summary> 
     331        /// Literal4032 コントロール。 
     332        /// </summary> 
     333        /// <remarks> 
     334        /// 自動生成されたフィールド。 
     335        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     336        /// </remarks> 
     337        protected global::System.Web.UI.WebControls.Literal Literal4032; 
     338         
     339        /// <summary> 
     340        /// Literal4033 コントロール。 
     341        /// </summary> 
     342        /// <remarks> 
     343        /// 自動生成されたフィールド。 
     344        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     345        /// </remarks> 
     346        protected global::System.Web.UI.WebControls.Literal Literal4033; 
     347         
     348        /// <summary> 
     349        /// Button403 コントロール。 
     350        /// </summary> 
     351        /// <remarks> 
     352        /// 自動生成されたフィールド。 
     353        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     354        /// </remarks> 
     355        protected global::System.Web.UI.WebControls.Button Button403; 
     356         
     357        /// <summary> 
     358        /// FileUpload403 コントロール。 
     359        /// </summary> 
     360        /// <remarks> 
     361        /// 自動生成されたフィールド。 
     362        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     363        /// </remarks> 
     364        protected global::FCSoft.SilverFrost.Framework.Web.UI.WebControls.FileUpload FileUpload403; 
     365         
     366        /// <summary> 
     367        /// Literal9011 コントロール。 
     368        /// </summary> 
     369        /// <remarks> 
     370        /// 自動生成されたフィールド。 
     371        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     372        /// </remarks> 
     373        protected global::System.Web.UI.WebControls.Literal Literal9011; 
     374         
     375        /// <summary> 
     376        /// Literal9012 コントロール。 
     377        /// </summary> 
     378        /// <remarks> 
     379        /// 自動生成されたフィールド。 
     380        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     381        /// </remarks> 
     382        protected global::System.Web.UI.WebControls.Literal Literal9012; 
     383         
     384        /// <summary> 
     385        /// Button901 コントロール。 
     386        /// </summary> 
     387        /// <remarks> 
     388        /// 自動生成されたフィールド。 
     389        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     390        /// </remarks> 
     391        protected global::System.Web.UI.WebControls.Button Button901; 
     392         
     393        /// <summary> 
     394        /// FileUpload901 コントロール。 
     395        /// </summary> 
     396        /// <remarks> 
     397        /// 自動生成されたフィールド。 
     398        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     399        /// </remarks> 
     400        protected global::System.Web.UI.WebControls.FileUpload FileUpload901; 
     401         
     402        /// <summary> 
     403        /// Literal9021 コントロール。 
     404        /// </summary> 
     405        /// <remarks> 
     406        /// 自動生成されたフィールド。 
     407        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     408        /// </remarks> 
     409        protected global::System.Web.UI.WebControls.Literal Literal9021; 
     410         
     411        /// <summary> 
     412        /// Literal9022 コントロール。 
     413        /// </summary> 
     414        /// <remarks> 
     415        /// 自動生成されたフィールド。 
     416        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     417        /// </remarks> 
     418        protected global::System.Web.UI.WebControls.Literal Literal9022; 
     419         
     420        /// <summary> 
     421        /// Button902 コントロール。 
     422        /// </summary> 
     423        /// <remarks> 
     424        /// 自動生成されたフィールド。 
     425        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     426        /// </remarks> 
     427        protected global::System.Web.UI.WebControls.Button Button902; 
     428         
     429        /// <summary> 
     430        /// FileUpload902 コントロール。 
     431        /// </summary> 
     432        /// <remarks> 
     433        /// 自動生成されたフィールド。 
     434        /// 変更するには、フィールドの宣言をデザイナー ファイルから分離コード ファイルに移動します。 
     435        /// </remarks> 
     436        protected global::System.Web.UI.WebControls.FileUpload FileUpload902; 
    95437    } 
    96438} 

  • framework/trunk/WebLibrary/Sources/Reflections.cs

    r1624 r1639  
    163163 
    164164        /// <summary> 
     165        /// <see cref="System.Web.HttpRawUploadedContent"/> に関係するリフレクションの集合です。 
     166        /// </summary> 
     167        internal static class HttpRawUploadedContent 
     168        { 
     169            /// <summary> 
     170            /// 実際の型です。 
     171            /// </summary> 
     172            private static readonly Type RealTypeInstance; 
     173 
     174            /// <summary> 
     175            /// インスタンスを作成するデリゲートです。 
     176            /// </summary> 
     177            private static readonly Func<int, int, object> CreateInstanceDelegate; 
     178 
     179            /// <summary> 
     180            /// <c>_data</c> フィールドに値を設定するデリゲートです。 
     181            /// </summary> 
     182            private static readonly Action<object, byte[]> SetDataDelegate; 
     183 
     184            /// <summary> 
     185            /// <c>_length</c> フィールドに値を設定するデリゲートです。 
     186            /// </summary> 
     187            private static readonly Action<object, int> SetLengthDelegate; 
     188 
     189            /// <summary> 
     190            /// <c>DoneAddingBytes</c> メソッドを呼び出すデリゲートです。 
     191            /// </summary> 
     192            private static readonly Action<object> DoneAddingBytesDelegate; 
     193 
     194 
     195            /// <summary> 
     196            /// クラスを初期化します。 
     197            /// </summary> 
     198            static HttpRawUploadedContent() 
     199            { 
     200                Type type = typeof(System.Web.HttpPostedFile).Assembly.GetType("System.Web.HttpRawUploadedContent", false); 
     201                if (type == null) 
     202                { 
     203                    return; 
     204                } 
     205 
     206                RealTypeInstance = type; 
     207 
     208                ConstructorInfo constructorInfo 
     209                    = type.GetConstructor( 
     210                        BindingFlags.Instance | BindingFlags.NonPublic, 
     211                        null, 
     212                        new[] { typeof(int), typeof(int) }, 
     213                        null); 
     214                if (constructorInfo == null) 
     215                { 
     216                    return; 
     217                } 
     218 
     219                CreateInstanceDelegate = delegate(int fileThreshold, int expectedLength) 
     220                { 
     221                    return constructorInfo.Invoke(new object[] { fileThreshold, expectedLength }); 
     222                }; 
     223 
     224 
     225                FieldInfo dataFieldInfo = type.GetField("_data", BindingFlags.Instance | BindingFlags.NonPublic); 
     226                if (dataFieldInfo == null) 
     227                { 
     228                    return; 
     229                } 
     230 
     231                SetDataDelegate = delegate(object obj, byte[] data) 
     232                { 
     233                    dataFieldInfo.SetValue(obj, data); 
     234                }; 
     235 
     236 
     237                FieldInfo lengthFieldInfo = type.GetField("_length", BindingFlags.Instance | BindingFlags.NonPublic); 
     238                if (lengthFieldInfo == null) 
     239                { 
     240                    return; 
     241                } 
     242 
     243                SetLengthDelegate = delegate(object obj, int length) 
     244                { 
     245                    lengthFieldInfo.SetValue(obj, length); 
     246                }; 
     247 
     248 
     249                MethodInfo doneAddingBytesMethodInfo 
     250                    = type.GetMethod("DoneAddingBytes", BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null); 
     251                if (doneAddingBytesMethodInfo == null) 
     252                { 
     253                    return; 
     254                } 
     255 
     256                DoneAddingBytesDelegate = delegate(object obj) 
     257                { 
     258                    doneAddingBytesMethodInfo.Invoke(obj, null); 
     259                }; 
     260            } 
     261 
     262 
     263            /// <summary> 
     264            /// 使用出来るかどうかを返します。 
     265            /// </summary> 
     266            /// <value> 
     267            /// 使用出来る場合は <see langword="true"/>。 
     268            /// それ以外の場合は <see langword="false"/>。 
     269            /// </value> 
     270            internal static bool IsValid 
     271            { 
     272                get 
     273                { 
     274                    return DoneAddingBytesDelegate != null; 
     275                } 
     276            } 
     277 
     278            /// <summary> 
     279            /// 実際の型を返します。 
     280            /// </summary> 
     281            /// <value> 
     282            /// 実際の型。 
     283            /// </value> 
     284            internal static Type RealType 
     285            { 
     286                get 
     287                { 
     288                    return RealTypeInstance; 
     289                } 
     290            } 
     291 
     292 
     293            /// <summary> 
     294            /// インスタンスを作成して返します。 
     295            /// </summary> 
     296            /// <param name="data">インスタンスで保持するデータ。</param> 
     297            /// <returns> 
     298            /// 作成されたインスタンス。 
     299            /// </returns> 
     300            internal static object CreateInstance(byte[] data) 
     301            { 
     302                if (CreateInstanceDelegate == null) 
     303                { 
     304                    return null; 
     305                } 
     306 
     307                object obj = CreateInstanceDelegate(data.Length, 0); 
     308                SetDataDelegate(obj, data); 
     309                SetLengthDelegate(obj, data.Length); 
     310                DoneAddingBytesDelegate(obj); 
     311 
     312                return obj; 
     313            } 
     314        } 
     315 
     316 
     317        /// <summary> 
     318        /// <see cref="System.Web.HttpInputStream"/> に関係するリフレクションの集合です。 
     319        /// </summary> 
     320        internal static class HttpInputStream 
     321        { 
     322            /// <summary> 
     323            /// 実際の型です。 
     324            /// </summary> 
     325            private static readonly Type RealTypeInstance; 
     326 
     327            /// <summary> 
     328            /// インスタンスを作成するデリゲートです。 
     329            /// </summary> 
     330            private static readonly Func<object, int, int, object> CreateInstanceDelegate; 
     331 
     332            /// <summary> 
     333            /// <c>GetAsByteArray</c> メソッドを呼び出すデリゲートです。 
     334            /// </summary> 
     335            private static readonly Func<object, byte[]> GetAsByteArrayDelegate; 
     336 
     337 
     338            /// <summary> 
     339            /// クラスを初期化します。 
     340            /// </summary> 
     341            static HttpInputStream() 
     342            { 
     343                if (!HttpRawUploadedContent.IsValid) 
     344                { 
     345                    return; 
     346                } 
     347 
     348                Type type = typeof(System.Web.HttpPostedFile).Assembly.GetType("System.Web.HttpInputStream", false); 
     349                if (type == null) 
     350                { 
     351                    return; 
     352                } 
     353 
     354                RealTypeInstance = type; 
     355 
     356                ConstructorInfo constructorInfo 
     357                    = type.GetConstructor( 
     358                        BindingFlags.Instance | BindingFlags.NonPublic, 
     359                        null, 
     360                        new[] { HttpRawUploadedContent.RealType, typeof(int), typeof(int) }, 
     361                        null); 
     362                if (constructorInfo == null) 
     363                { 
     364                    return; 
     365                } 
     366 
     367                CreateInstanceDelegate = delegate(object data, int offset, int length) 
     368                { 
     369                    return constructorInfo.Invoke(new[] { data, offset, length }); 
     370                }; 
     371 
     372 
     373                MethodInfo getAsByteArrayMethodInfo 
     374                    = type.GetMethod("GetAsByteArray", BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null); 
     375                if (getAsByteArrayMethodInfo == null) 
     376                { 
     377                    return; 
     378                } 
     379 
     380                GetAsByteArrayDelegate = delegate(object obj) 
     381                { 
     382                    return (byte[])getAsByteArrayMethodInfo.Invoke(obj, null); 
     383                }; 
     384            } 
     385 
     386 
     387            /// <summary> 
     388            /// 使用出来るかどうかを返します。 
     389            /// </summary> 
     390            /// <value> 
     391            /// 使用出来る場合は <see langword="true"/>。 
     392            /// それ以外の場合は <see langword="false"/>。 
     393            /// </value> 
     394            internal static bool IsValid 
     395            { 
     396                get 
     397                { 
     398                    return CreateInstanceDelegate != null 
     399                        && GetAsByteArrayDelegate != null; 
     400                } 
     401            } 
     402 
     403            /// <summary> 
     404            /// 実際の型を返します。 
     405            /// </summary> 
     406            /// <value> 
     407            /// 実際の型。 
     408            /// </value> 
     409            internal static Type RealType 
     410            { 
     411                get 
     412                { 
     413                    return RealTypeInstance; 
     414                } 
     415            } 
     416 
     417 
     418            /// <summary> 
     419            /// インスタンスを作成して返します。 
     420            /// </summary> 
     421            /// <param name="data">アップロードしたコンテンツ。</param> 
     422            /// <param name="offset">オフセット。</param> 
     423            /// <param name="length">長さ。</param> 
     424            /// <returns> 
     425            /// 作成されたインスタンス。 
     426            /// </returns> 
     427            internal static object CreateInstance(object data, int offset, int length) 
     428            { 
     429                if (CreateInstanceDelegate == null) 
     430                { 
     431                    return null; 
     432                } 
     433 
     434                return CreateInstanceDelegate(data, offset, length); 
     435            } 
     436 
     437            /// <summary> 
     438            /// 全てのデータのバイト配列を作成して返します。 
     439            /// </summary> 
     440            /// <param name="obj">オブジェクト。</param> 
     441            /// <returns> 
     442            /// 全てのデータのバイト配列。 
     443            /// </returns> 
     444            internal static byte[] GetAsByteArray(object obj) 
     445            { 
     446                if (GetAsByteArrayDelegate == null) 
     447                { 
     448                    return null; 
     449                } 
     450 
     451                return GetAsByteArrayDelegate(obj); 
     452            } 
     453        } 
     454 
     455 
     456        /// <summary> 
     457        /// <see cref="System.Web.HttpPostedFile"/> に関係するリフレクションの集合です。 
     458        /// </summary> 
     459        internal static class HttpPostedFile 
     460        { 
     461            /// <summary> 
     462            /// インスタンスを作成するデリゲートです。 
     463            /// </summary> 
     464            private static readonly Func<string, string, object, System.Web.HttpPostedFile> CreateInstanceDelegate; 
     465 
     466 
     467            /// <summary> 
     468            /// クラスを初期化します。 
     469            /// </summary> 
     470            static HttpPostedFile() 
     471            { 
     472                if (!HttpInputStream.IsValid) 
     473                { 
     474                    return; 
     475                } 
     476 
     477                ConstructorInfo constructorInfo 
     478                    = typeof(System.Web.HttpPostedFile).GetConstructor( 
     479                        BindingFlags.Instance | BindingFlags.NonPublic, 
     480                        null, 
     481                        new[] { typeof(string), typeof(string), HttpInputStream.RealType }, 
     482                        null); 
     483                if (constructorInfo == null) 
     484                { 
     485                    return; 
     486                } 
     487 
     488                CreateInstanceDelegate = delegate(string filename, string contentType, object stream) 
     489                { 
     490                    return (System.Web.HttpPostedFile)constructorInfo.Invoke(new[] { filename, contentType, stream }); 
     491                }; 
     492            } 
     493 
     494 
     495            /// <summary> 
     496            /// 使用出来るかどうかを返します。 
     497            /// </summary> 
     498            /// <value> 
     499            /// 使用出来る場合は <see langword="true"/>。 
     500            /// それ以外の場合は <see langword="false"/>。 
     501            /// </value> 
     502            internal static bool IsValid 
     503            { 
     504                get 
     505                { 
     506                    return CreateInstanceDelegate != null; 
     507                } 
     508            } 
     509 
     510 
     511            /// <summary> 
     512            /// インスタンスを作成して返します。 
     513            /// </summary> 
     514            /// <param name="filename">ファイル名。</param> 
     515            /// <param name="contentType">コンテンツタイプ。</param> 
     516            /// <param name="stream">ストリーム。</param> 
     517            /// <returns> 
     518            /// 作成されたインスタンス。 
     519            /// </returns> 
     520            internal static System.Web.HttpPostedFile CreateInstance(string filename, string contentType, object stream) 
     521            { 
     522                if (CreateInstanceDelegate == null) 
     523                { 
     524                    return null; 
     525                } 
     526 
     527                return CreateInstanceDelegate(filename, contentType, stream); 
     528            } 
     529        } 
     530 
     531 
     532        /// <summary> 
    165533        /// <see cref="System.Web.Security.FormsAuthentication"/> に関係するリフレクションの集合です。 
    166534        /// </summary> 

  • framework/trunk/WebLibrary/Sources/UI/WebControls/FileUpload.cs

    r1637 r1639  
    2424{ 
    2525    using System; 
     26    using System.Collections.Generic; 
     27    using System.Collections.ObjectModel; 
    2628    using System.Collections.Specialized; 
    2729    using System.ComponentModel; 
     30    using System.Diagnostics; 
     31    using System.IO; 
    2832    using System.Web; 
    2933    using System.Web.UI; 
    … …  
    3135 
    3236    /// <summary> 
    33     /// ユーザーがファイルを選択してサーバーにアップロードするための 
    34     /// テキスト ボックス コントロールと参照ボタンを表示します。 
     37    /// ユーザーがファイルを選択してサーバーにアップロードするための参照ボタンを表示します。 
    3538    /// </summary> 
    3639    [WebDescription("Description_FileUpload")] 
    … …  
    6164        private const string ValidationGroupKey = "ValidationGroup"; 
    6265 
     66        /// <summary> 
     67        /// <see cref="CachePostedFile"/> プロパティ用のキー。 
     68        /// </summary> 
     69        private const string CachePostedFileKey = "CachePostedFile"; 
     70 
    6371 
    6472        /// <summary> 
    … …  
    6674        /// </summary> 
    6775        private static readonly object EventFileSelectedKey = new object(); 
     76 
     77        /// <summary> 
     78        /// 空の <see cref="HttpPostedFile"/> の配列。 
     79        /// </summary> 
     80        private static readonly HttpPostedFile[] EmptyPostedFiles = new HttpPostedFile[0]; 
     81 
     82 
     83        /// <summary> 
     84        /// キャッシュしたファイルのコレクション。 
     85        /// </summary> 
     86        private CachedPostedFileCollection cachedPostedFiles; 
     87 
     88        /// <summary> 
     89        /// ファイルの情報をクリアするかどうか。 
     90        /// </summary> 
     91        private bool clearFiles; 
    6892 
    6993 
    … …  
    204228        } 
    205229 
     230        /// <summary> 
     231        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルを 
     232        /// 保持し続けるかどうかを設定または取得します。 
     233        /// </summary> 
     234        /// <value> 
     235        /// ポストされたファイルを保持する場合は <see langword="true"/>。 
     236        /// それ以外の場合は <see langword="false"/>。 
     237        /// 既定値は <see langword="false"/>。 
     238        /// </value> 
     239        /// <remarks> 
     240        /// <para> 
     241        /// このプロパティを <see langword="true"/> に設定すると、 
     242        /// アップロードが行われたポストバック時にアップロードされたファイルをビューステートに保持し、 
     243        /// 次回のポストバック時にアップロードされたファイルの内容にアクセスできるようになります。 
     244        /// </para> 
     245        /// <para> 
     246        /// 保持しているファイルをクリアしたい場合は <see cref="ClearFiles"/> 
     247        /// メソッドを呼び出します。 
     248        /// </para> 
     249        /// </remarks> 
     250        [Themeable(false)] 
     251        [DefaultValue(false)] 
     252        [WebCategory("Behavior")] 
     253        [WebDescription("Description_CachePostedFile")] 
     254        public virtual bool CachePostedFile 
     255        { 
     256            get 
     257            { 
     258                return (bool)(ViewState[CachePostedFileKey] ?? false); 
     259            } 
     260 
     261            set 
     262            { 
     263                ViewState[CachePostedFileKey] = value; 
     264            } 
     265        } 
     266 
     267 
     268        /// <summary> 
     269        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルに格納されているバイトの配列を取得します。 
     270        /// </summary> 
     271        /// <value> 
     272        /// アップロードされたファイルに格納されていた <see cref="byte"/> 配列。 
     273        /// </value> 
     274        /// <remarks> 
     275        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     276        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     277        /// この場合、このプロパティは最後にアップロードされた時のファイルに格納されていたバイト配列を返します。 
     278        /// </remarks> 
     279        [Browsable(false)] 
     280        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     281        public new byte[] FileBytes 
     282        { 
     283            get 
     284            { 
     285                HttpPostedFile postedFile = PostedFile; 
     286                return postedFile != null 
     287                    ? Reflections.HttpInputStream.GetAsByteArray(postedFile.InputStream) 
     288                    : new byte[0]; 
     289            } 
     290        } 
     291 
     292        /// <summary> 
     293        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルを指す 
     294        /// <see cref="Stream"/> オブジェクトを取得します。 
     295        /// </summary> 
     296        /// <value> 
     297        /// <see cref="FileUpload"/> を使用してアップロードされたファイルを指す <see cref="Stream"/>。 
     298        /// </value> 
     299        /// <remarks> 
     300        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     301        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     302        /// この場合、このプロパティは最後にアップロードされた時のファイルを指すストリームを返します。 
     303        /// </remarks> 
     304        [Browsable(false)] 
     305        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     306        [DebuggerBrowsable(DebuggerBrowsableState.Never)] 
     307        public new Stream FileContent 
     308        { 
     309            get 
     310            { 
     311                HttpPostedFile postedFile = PostedFile; 
     312                return postedFile != null 
     313                    ? postedFile.InputStream 
     314                    : Stream.Null; 
     315            } 
     316        } 
     317 
     318        /// <summary> 
     319        /// ファイルが <see cref="FileUpload"/> コントロールに格納されているかどうかを示す値を取得します。 
     320        /// </summary> 
     321        /// <value> 
     322        /// ファイルが <see cref="FileUpload"/> コントロールに格納されている場合は <see langword="true"/>。 
     323        /// それ以外の場合は <see langword="false"/>。 
     324        /// ASP.NET の標準の実装とは異なり、空のファイルをアップロードした場合でも <see langword="true"/> を返します。 
     325        /// また、ファイルのストリームをクローズした後でも <see langword="true"/> を返しますが、 
     326        /// ファイルの長さ (<see cref="HttpPostedFile.ContentLength"/>) は <c>0</c> となります。 
     327        /// </value> 
     328        /// <remarks> 
     329        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     330        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     331        /// この場合、このプロパティは <see langword="true"/> を返します。 
     332        /// </remarks> 
     333        [Browsable(false)] 
     334        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     335        public new bool HasFile 
     336        { 
     337            get 
     338            { 
     339                return PostedFile != null; 
     340            } 
     341        } 
     342 
     343        /// <summary> 
     344        /// ファイルが <see cref="FileUpload"/> コントロールに格納されているかどうかを示す値を取得します。 
     345        /// </summary> 
     346        /// <value> 
     347        /// ファイルが <see cref="FileUpload"/> コントロールに格納されている場合は <see langword="true"/>。 
     348        /// それ以外の場合は <see langword="false"/>。 
     349        /// ASP.NET の標準の実装とは異なり、空のファイルをアップロードした場合でも <see langword="true"/> を返します。 
     350        /// また、ファイルのストリームをクローズした後でも <see langword="true"/> を返しますが、 
     351        /// ファイルの長さ (<see cref="HttpPostedFile.ContentLength"/>) は <c>0</c> となります。 
     352        /// </value> 
     353        /// <remarks> 
     354        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     355        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     356        /// この場合、このプロパティは <see langword="true"/> を返します。 
     357        /// </remarks> 
     358        [Browsable(false)] 
     359        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     360        public new bool HasFiles 
     361        { 
     362            get 
     363            { 
     364                return PostedFiles.Count > 0; 
     365            } 
     366        } 
     367 
     368        /// <summary> 
     369        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルの基になる 
     370        /// <see cref="HttpPostedFile"/> オブジェクトを取得します。 
     371        /// </summary> 
     372        /// <value> 
     373        /// <see cref="FileUpload"/> コントロールを使用してアップロードされた <see cref="HttpPostedFile"/> オブジェクト。 
     374        /// <see cref="HasFile"/> プロパティが <see langword="false"/> 
     375        /// を返す場合は <see langword="null"/>です。 
     376        /// </value> 
     377        /// <remarks> 
     378        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     379        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     380        /// この場合、このプロパティは最後にアップロードされた時のファイルを返します。 
     381        /// </remarks> 
     382        [Browsable(false)] 
     383        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     384        public new HttpPostedFile PostedFile 
     385        { 
     386            get 
     387            { 
     388                // クリアされている場合 
     389                if (clearFiles) 
     390                { 
     391                    return null; 
     392                } 
     393 
     394                Page page = Page; 
     395                if (page == null || !page.IsPostBack) 
     396                { 
     397                    return null; 
     398                } 
     399 
     400                // キャッシュされていればキャッシュから返す 
     401                if (cachedPostedFiles != null) 
     402                { 
     403                    return cachedPostedFiles.PostedFile; 
     404                } 
     405 
     406                HttpPostedFile postedFile = base.PostedFile; 
     407                return IsValidPostedFile(postedFile) 
     408                    ? postedFile 
     409                    : null; 
     410            } 
     411        } 
     412 
     413        /// <summary> 
     414        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルのコレクションを取得します。 
     415        /// </summary> 
     416        /// <value> 
     417        /// <see cref="FileUpload"/> コントロールを使用してアップロードされたファイルのコレクション。 
     418        /// <see cref="HasFiles"/> プロパティが <see langword="false"/> 
     419        /// を返す場合は空のコレクションです。 
     420        /// </value> 
     421        /// <remarks> 
     422        /// <see cref="CachePostedFile"/> が <see langword="true"/> の場合、 
     423        /// 一度格納されたファイルはポストバックを繰り返しても保持されます。 
     424        /// この場合、このプロパティは最後にアップロードされた時のファイルのコレクションを返します。 
     425        /// </remarks> 
     426        [Browsable(false)] 
     427        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] 
     428        public new IList<HttpPostedFile> PostedFiles 
     429        { 
     430            get 
     431            { 
     432                // クリアされている場合 
     433                if (clearFiles) 
     434                { 
     435                    return EmptyPostedFiles; 
     436                } 
     437 
     438                // キャッシュされていればキャッシュから返す 
     439                if (cachedPostedFiles != null) 
     440                { 
     441                    return cachedPostedFiles.PostedFiles; 
     442                } 
     443 
     444                IList<HttpPostedFile> postedFiles = base.PostedFiles; 
     445                return IsValidPostedFiles(postedFiles) 
     446                    ? postedFiles 
     447                    : EmptyPostedFiles; 
     448            } 
     449        } 
     450 
     451 
     452        /// <summary> 
     453        /// このコントロールに格納されているファイル情報を削除します。 
     454        /// </summary> 
     455        public void ClearFiles() 
     456        { 
     457            cachedPostedFiles = null; 
     458            clearFiles = true; 
     459        } 
     460 
    206461 
    207462        #region IPostBackDataHandler メンバ 
    … …  
    237492 
    238493        /// <summary> 
     494        /// <see cref="FileUpload"/> コントロールの保存された状態を読み込みます。 
     495        /// </summary> 
     496        /// <param name="savedState"> 
     497        /// <see cref="FileUpload"/> の保存された状態を格納している 
     498        /// <see cref="object"/>。 
     499        /// </param> 
     500        protected override void LoadViewState(object savedState) 
     501        { 
     502            if (savedState == null) 
     503            { 
     504                return; 
     505            } 
     506 
     507            Pair state = (Pair)savedState; 
     508 
     509            // 親を呼び出す 
     510            base.LoadViewState(state.First); 
     511 
     512            if (state.Second != null) 
     513            { 
     514                cachedPostedFiles = CachedPostedFileCollection.CreateFromViewState(state.Second); 
     515            } 
     516        } 
     517 
     518        /// <summary> 
     519        /// <see cref="FileUpload"/> コントロールの状態を格納します。 
     520        /// </summary> 
     521        /// <returns> 
     522        /// <see cref="FileUpload"/> の保存された状態を格納しているオブジェクト。 
     523        /// </returns> 
     524        protected override object SaveViewState() 
     525        { 
     526            // 親を呼び出す 
     527            Pair state = new Pair 
     528            { 
     529                First = base.SaveViewState(), 
     530            }; 
     531 
     532            // 保持するデータが有る場合 
     533            if (EnsurePostedFileCache()) 
     534            { 
     535                state.Second = cachedPostedFiles.ToViewState(); 
     536            } 
     537 
     538            if (state.First == null && state.Second == null) 
     539            { 
     540                return null; 
     541            } 
     542 
     543            return state; 
     544        } 
     545 
     546        /// <summary> 
    239547        /// コントロールのポストバック データを処理します。 
    240548        /// </summary> 
    … …  
    256564            } 
    257565 
    258             // ファイルがポストされていれば true を返す 
    259             HttpPostedFile postedFile = PostedFile; 
    260             return postedFile != null 
    261                 && (!string.IsNullOrEmpty(postedFile.FileName) || postedFile.ContentLength > 0); 
     566            // ファイルがポストされていなければ false を返す 
     567            if (!IsValidPostedFile(base.PostedFile)) 
     568            { 
     569                return false; 
     570            } 
     571 
     572            // ポストされたファイルが有るのでキャッシュをクリアしてキャッシュし直す 
     573            cachedPostedFiles = null; 
     574            EnsurePostedFileCache(); 
     575 
     576            return true; 
    262577        } 
    263578 
    … …  
    360675            if (page != null) 
    361676            { 
     677                string onChange = null; 
     678                if (HasAttributes) 
     679                { 
     680                    onChange = Attributes["onchange"]; 
     681                    if (onChange != null) 
     682                    { 
     683                        onChange = ClientScriptUtility.EnsureEndWithSemiColon(onChange); 
     684                        Attributes.Remove("onchange"); 
     685                    } 
     686                } 
     687 
     688                onChange = ClientScriptUtility.MergeScript(onChange, GetOnClientChanged(), false); 
     689 
    362690                if (AutoPostBack) 
    363691                { 
    364                     string onChange = null; 
    365                     if (HasAttributes) 
    366                     { 
    367                         onChange = Attributes["onchange"]; 
    368                         if (onChange != null) 
    369                         { 
    370                             onChange = ClientScriptUtility.EnsureEndWithSemiColon(onChange); 
    371                             Attributes.Remove("onchange"); 
    372                         } 
    373                     } 
    374  
    375692                    PostBackOptions options = new PostBackOptions(this, string.Empty); 
    376693                    if (CausesValidation) 
    … …  
    385702                    } 
    386703 
    387                     writer.AddAttribute( 
    388                         HtmlTextWriterAttribute.Onchange, 
    389                         ClientScriptUtility.MergeScript(onChange, page.ClientScript.GetPostBackEventReference(options, true), false)); 
     704                    onChange = ClientScriptUtility.MergeScript(onChange, page.ClientScript.GetPostBackEventReference(options, true), false); 
    390705                } 
    391706                else 
    392707                { 
     708                    // GetPostBackEventReference を呼び出していないので登録する 
    393709                    page.ClientScript.RegisterForEventValidation(UniqueID, string.Empty); 
     710                } 
     711 
     712                if (onChange != null) 
     713                { 
     714                    writer.AddAttribute(HtmlTextWriterAttribute.Onchange, onChange); 
    394715                } 
    395716            } 
    … …  
    403724            base.AddAttributesToRender(writer); 
    404725        } 
     726 
     727        /// <summary> 
     728        /// クライアントサイドで実行される <c>onchange</c> イベントハンドラを取得します。 
     729        /// </summary> 
     730        /// <returns> 
     731        /// クライアントサイドで実行される <c>onchange</c> イベントハンドラ。 
     732        /// </returns> 
     733        protected virtual string GetOnClientChanged() 
     734        { 
     735            return null; 
     736        } 
     737 
     738        /// <summary> 
     739        /// 有効なポストされたファイルかどうかを返します。 
     740        /// </summary> 
     741        /// <param name="postedFile"><see cref="HttpPostedFile"/>。</param> 
     742        /// <returns> 
     743        /// 有効な場合は <see langword="true"/>。 
     744        /// それ以外の場合は <see langword="false"/>。 
     745        /// </returns> 
     746        private static bool IsValidPostedFile(HttpPostedFile postedFile) 
     747        { 
     748            return postedFile != null 
     749                && (!string.IsNullOrEmpty(postedFile.FileName) || postedFile.ContentLength > 0); 
     750        } 
     751 
     752        /// <summary> 
     753        /// 有効なポストされたファイルかどうかを返します。 
     754        /// </summary> 
     755        /// <param name="postedFiles"><see cref="HttpPostedFile"/> のリスト。</param> 
     756        /// <returns> 
     757        /// 有効な場合は <see langword="true"/>。 
     758        /// それ以外の場合は <see langword="false"/>。 
     759        /// </returns> 
     760        private static bool IsValidPostedFiles(IList<HttpPostedFile> postedFiles) 
     761        { 
     762            if (postedFiles == null) 
     763            { 
     764                return false; 
     765            } 
     766 
     767            // おそらく、ポストバックではない場合 
     768            if (postedFiles.Count == 0) 
     769            { 
     770                return true; 
     771            } 
     772 
     773            // 実際は未指定 (ポストされなかった場合) だった場合でも、一つデータが存在する 
     774            if (postedFiles.Count == 1 && !IsValidPostedFile(postedFiles[0])) 
     775            { 
     776                return false; 
     777            } 
     778 
     779            return true; 
     780        } 
     781 
     782        /// <summary> 
     783        /// ポストされたファイルが保持されていない場合に保持します。 
     784        /// </summary> 
     785        /// <returns> 
     786        /// 保持するデータがある場合は <see langword="true"/>。 
     787        /// それ以外の場合は <see langword="false"/>。 
     788        /// </returns> 
     789        private bool EnsurePostedFileCache() 
     790        { 
     791            // クリアされていれば保持しない 
     792            if (clearFiles) 
     793            { 
     794                return false; 
     795            } 
     796 
     797            // 保持する設定になっていない場合 
     798            if (!CachePostedFile) 
     799            { 
     800                return false; 
     801            } 
     802 
     803            // ポストバック時ではない場合は保持しない (そもそもアップロードファイルが無い) 
     804            Page page = Page; 
     805            if (page != null && !page.IsPostBack) 
     806            { 
     807                return false; 
     808            } 
     809 
     810            // 既に保持するデータを準備済の場合 
     811            if (cachedPostedFiles != null) 
     812            { 
     813                return true; 
     814            } 
     815 
     816            UpdatePostedFileCache(); 
     817            return cachedPostedFiles != null; 
     818        } 
     819 
     820        /// <summary> 
     821        /// ポストされたファイルのキャッシュ情報を更新します。 
     822        /// </summary> 
     823        private void UpdatePostedFileCache() 
     824        { 
     825            cachedPostedFiles = CachedPostedFileCollection.CreateFrom(base.PostedFiles); 
     826        } 
     827 
     828 
     829 
     830        /// <summary> 
     831        /// アップロードされたファイルの保存情報を保持するクラスです。 
     832        /// </summary> 
     833        [Serializable] 
     834        [DebuggerDisplay(@"\{FileName = {fileName}\}")] 
     835        private sealed class CachedPostedFile 
     836        { 
     837            /// <summary> 
     838            /// ファイル名。 
     839            /// </summary> 
     840            [DebuggerBrowsable(DebuggerBrowsableState.Never)] 
     841            private readonly string fileName; 
     842 
     843            /// <summary> 
     844            /// MIME コンテンツタイプ。 
     845            /// </summary> 
     846            [DebuggerBrowsable(DebuggerBrowsableState.Never)] 
     847            private readonly string contentType; 
     848 
     849            /// <summary> 
     850            /// ファイルの内容を表すバイト配列。 
     851            /// </summary> 
     852            /// <remarks> 
     853            /// ファイルが空の場合は <see langword="null"/>。 
     854            /// </remarks> 
     855            [DebuggerBrowsable(DebuggerBrowsableState.Never)] 
     856            private readonly byte[] contents; 
     857 
     858 
     859            /// <summary> 
     860            /// インスタンスを作成します。 
     861            /// </summary> 
     862            /// <param name="postedFile">ポストされたファイル。</param> 
     863            internal CachedPostedFile(HttpPostedFile postedFile) 
     864            { 
     865                fileName = Path.GetFileName(postedFile.FileName); 
     866                contentType = postedFile.ContentType; 
     867                contents = Reflections.HttpInputStream.GetAsByteArray(postedFile.InputStream); 
     868            } 
     869 
     870 
     871            /// <summary> 
     872            /// ファイル名を取得します。 
     873            /// </summary> 
     874            /// <value> 
     875            /// ファイル名。 
     876            /// </value> 
     877            internal string FileName 
     878            { 
     879                get 
     880                { 
     881                    return fileName; 
     882                } 
     883            } 
     884 
     885            /// <summary> 
     886            /// MIME コンテンツタイプを取得します。 
     887            /// </summary> 
     888            /// <value> 
     889            /// MIME コンテンツタイプ。 
     890            /// </value> 
     891            internal string ContentType 
     892            { 
     893                get 
     894                { 
     895                    return contentType; 
     896                } 
     897            } 
     898 
     899            /// <summary> 
     900            /// ファイルの内容を表すバイト配列を取得します。 
     901            /// </summary> 
     902            /// <value> 
     903            /// ファイルの内容を表すバイト配列。 
     904            /// ファイルが空の場合は <see langword="null"/>。 
     905            /// </value> 
     906            internal byte[] Contents 
     907            { 
     908                get 
     909                { 
     910                    return contents; 
     911                } 
     912            } 
     913        } 
     914 
     915 
     916 
     917        /// <summary> 
     918        /// アップロードされたファイルの保存情報を保持するクラスです。 
     919        /// </summary> 
     920        [DebuggerDisplay(@"Count = {Count}")] 
     921        private sealed class CachedPostedFileCollection : 
     922            Collection<CachedPostedFile> 
     923        { 
     924            /// <summary> 
     925            /// このコレクションの要素を元に作成された <see cref="HttpPostedFile"/> の読み取り専用のリスト。 
     926            /// </summary> 
     927            private IList<HttpPostedFile> postedFiles; 
     928 
     929 
     930            /// <summary> 
     931            /// インスタンスを作成します。 
     932            /// </summary> 
     933            /// <param name="list"><see cref="FileUpload.CachePostedFile"/> の配列。</param> 
     934            private CachedPostedFileCollection(CachedPostedFile[] list) 
     935                : base(list) 
     936            { 
     937                Debug.Assert(list.Length > 0, "Invalid count"); 
     938            } 
     939 
     940 
     941            /// <summary> 
     942            /// 格納されたファイルを取得します。 
     943            /// </summary> 
     944            /// <value> 
     945            /// 格納されたファイル。 
     946            /// </value> 
     947            internal HttpPostedFile PostedFile 
     948            { 
     949                get 
     950                { 
     951                    return PostedFiles[0]; 
     952                } 
     953            } 
     954 
     955            /// <summary> 
     956            /// 格納されたファイルのコレクションを取得します。 
     957            /// </summary> 
     958            /// <value> 
     959            /// 格納されたファイルのコレクション。 
     960            /// </value> 
     961            internal IList<HttpPostedFile> PostedFiles 
     962            { 
     963                get 
     964                { 
     965                    if (postedFiles == null) 
     966                    { 
     967                        HttpPostedFile[] newPostedFiles = new HttpPostedFile[Count]; 
     968                        for (int i = 0; i < Count; i++) 
     969                        { 
     970                            CachedPostedFile cachedPostedFile = this[i]; 
     971 
     972                            // 長さが 0 のファイルの場合は Contents が null 
     973                            byte[] contents = cachedPostedFile.Contents; 
     974 
     975                            newPostedFiles[i] 
     976                                = Reflections.HttpPostedFile.CreateInstance( 
     977                                    cachedPostedFile.FileName, 
     978                                    cachedPostedFile.ContentType, 
     979                                    Reflections.HttpInputStream.CreateInstance( 
     980                                        contents != null 
     981                                            ? Reflections.HttpRawUploadedContent.CreateInstance(contents) 
     982                                            : null, 
     983                                        0, 
     984                                        contents != null 
     985                                            ? contents.Length 
     986                                            : 0)); 
     987                        } 
     988 
     989                        postedFiles = Array.AsReadOnly(newPostedFiles); 
     990                    } 
     991 
     992                    return postedFiles; 
     993                } 
     994            } 
     995 
     996            /// <summary> 
     997            /// ポストされたファイルのリストからインスタンスを作成して返します。 
     998            /// </summary> 
     999            /// <param name="postedFiles">ポストされたファイルのリスト。</param> 
     1000            /// <returns> 
     1001            /// キャッシュするデータのコレクション。 
     1002            /// 有効なポストされたファイルが無い場合は <see langword="null"/>。 
     1003            /// </returns> 
     1004            internal static CachedPostedFileCollection CreateFrom(IList<HttpPostedFile> postedFiles) 
     1005            { 
     1006                if (postedFiles == null || postedFiles.Count == 0 || !IsValidPostedFiles(postedFiles)) 
     1007                { 
     1008                    return null; 
     1009                } 
     1010 
     1011                CachedPostedFile[] cachedPostedFiles = new CachedPostedFile[postedFiles.Count]; 
     1012                for (int i = 0; i < postedFiles.Count; i++) 
     1013                { 
     1014                    cachedPostedFiles[i] = new CachedPostedFile(postedFiles[i]); 
     1015                } 
     1016 
     1017                return new CachedPostedFileCollection(cachedPostedFiles); 
     1018            } 
     1019 
     1020            /// <summary> 
     1021            /// ビューステートに保存したデータからインスタンスを作成します。 
     1022            /// </summary> 
     1023            /// <param name="viewState">ビューステート。</param> 
     1024            /// <returns> 
     1025            /// <paramref name="viewState"/> を元に作成したインスタンス。 
     1026            /// </returns> 
     1027            internal static CachedPostedFileCollection CreateFromViewState(object viewState) 
     1028            { 
     1029                return new CachedPostedFileCollection((CachedPostedFile[])viewState); 
     1030            } 
     1031 
     1032            /// <summary> 
     1033            /// ビューステートに保存するデータを取得します。 
     1034            /// </summary> 
     1035            /// <returns> 
     1036            /// ビューステートに保存するデータ。 
     1037            /// </returns> 
     1038            internal object ToViewState() 
     1039            { 
     1040                // 実体は配列 (コンストラクタで渡した配列) 
     1041                return Items; 
     1042            } 
     1043        } 
    4051044    } 
    4061045} 

  • framework/trunk/WebTest/Sources/ReflectionsTest.cs

    r1624 r1639  
    2020// </license> 
    2121// ---------------------------------------------------------------------------- 
     22// ReSharper disable ExceptionNotDocumented 
    2223namespace FCSoft.SilverFrost.Framework.Web 
    2324{ 
    … …  
    8485 
    8586        /// <summary> 
     87        /// <see cref="Reflections.HttpRawUploadedContent"/> が使用出来るかのテストです。 
     88        /// </summary> 
     89        [Test] 
     90        public void TestHttpRawUploadedContentIsValid() 
     91        { 
     92            Assert.That(Reflections.HttpRawUploadedContent.IsValid, Is.True); 
     93        } 
     94 
     95        /// <summary> 
     96        /// <see cref="Reflections.HttpRawUploadedContent"/> のインスタンスが作成できるかのテストです。 
     97        /// </summary> 
     98        [Test] 
     99        public void TestHttpRawUploadedContentCreateInstance() 
     100        { 
     101            Assert.That(Reflections.HttpRawUploadedContent.CreateInstance(new[] { (byte)1, (byte)2, }), Is.Not.Null); 
     102        } 
     103 
     104 
     105        /// <summary> 
     106        /// <see cref="Reflections.HttpInputStream"/> が使用出来るかのテストです。 
     107        /// </summary> 
     108        [Test] 
     109        public void TestHttpInputStreamIsValid() 
     110        { 
     111            Assert.That(Reflections.HttpInputStream.IsValid, Is.True); 
     112        } 
     113 
     114        /// <summary> 
     115        /// <see cref="Reflections.HttpInputStream"/> のインスタンスが作成できるかのテストです。 
     116        /// </summary> 
     117        [Test] 
     118        public void TestHttpInputStreamCreateInstance() 
     119        { 
     120            Assert.That( 
     121                Reflections.HttpInputStream.CreateInstance( 
     122                    Reflections.HttpRawUploadedContent.CreateInstance(new[] { (byte)1, (byte)2, }), 
     123                    0, 
     124                    2), 
     125                Is.Not.Null); 
     126        } 
     127 
     128        /// <summary> 
     129        /// <see cref="Reflections.HttpInputStream"/> のデータが空のインスタンスが作成できるかのテストです。 
     130        /// </summary> 
     131        [Test] 
     132        public void TestHttpInputStreamCreateInstanceForEmpty() 
     133        { 
     134            Assert.That( 
     135                Reflections.HttpInputStream.CreateInstance( 
     136                    Reflections.HttpRawUploadedContent.CreateInstance(new byte[0]), 
     137                    0, 
     138                    0), 
     139                Is.Not.Null); 
     140        } 
     141 
     142        /// <summary> 
     143        /// <see cref="Reflections.HttpInputStream"/> のデータが <see langword="null"/> のインスタンスが作成できるかのテストです。 
     144        /// </summary> 
     145        [Test] 
     146        public void TestHttpInputStreamCreateInstanceForNullContents() 
     147        { 
     148            Assert.That( 
     149                Reflections.HttpInputStream.CreateInstance( 
     150                    null, 
     151                    0, 
     152                    0), 
     153                Is.Not.Null); 
     154        } 
     155 
     156        /// <summary> 
     157        /// <see cref="Reflections.HttpInputStream.GetAsByteArray"/> のテストです。 
     158        /// </summary> 
     159        [Test] 
     160        public void TestHttpInputStreamGetAsByteArray() 
     161        { 
     162            object obj 
     163                = Reflections.HttpInputStream.CreateInstance( 
     164                    Reflections.HttpRawUploadedContent.CreateInstance(new[] { (byte)1, (byte)2, }), 
     165                    0, 
     166                    2); 
     167            Assert.That(obj, Is.Not.Null, "CreateInstance"); 
     168            byte[] data = Reflections.HttpInputStream.GetAsByteArray(obj); 
     169            Assert.That(data, Is.EqualTo(new[] { (byte)1, (byte)2, }), "GetAsByteArray"); 
     170        } 
     171 
     172        /// <summary> 
     173        /// <see cref="Reflections.HttpInputStream.GetAsByteArray"/> のデータが空のテストです。 
     174        /// </summary> 
     175        [Test] 
     176        public void TestHttpInputStreamGetAsByteArrayForEmpty() 
     177        { 
     178            object obj 
     179                = Reflections.HttpInputStream.CreateInstance( 
     180                    Reflections.HttpRawUploadedContent.CreateInstance(new byte[0]), 
     181                    0, 
     182                    0); 
     183            Assert.That(obj, Is.Not.Null, "CreateInstance"); 
     184            byte[] data = Reflections.HttpInputStream.GetAsByteArray(obj); 
     185            Assert.That(data, Is.Null, "GetAsByteArray"); 
     186        } 
     187 
     188        /// <summary> 
     189        /// <see cref="Reflections.HttpInputStream.GetAsByteArray"/> のデータが <see langword="null"/> のテストです。 
     190        /// </summary> 
     191        [Test] 
     192        public void TestHttpInputStreamGetAsByteArrayForNullContents() 
     193        { 
     194            object obj 
     195                = Reflections.HttpInputStream.CreateInstance( 
     196                    null, 
     197                    0, 
     198                    0); 
     199            Assert.That(obj, Is.Not.Null, "CreateInstance"); 
     200            byte[] data = Reflections.HttpInputStream.GetAsByteArray(obj); 
     201            Assert.That(data, Is.Null, "GetAsByteArray"); 
     202        } 
     203 
     204 
     205        /// <summary> 
     206        /// <see cref="Reflections.HttpPostedFile"/> が使用出来るかのテストです。 
     207        /// </summary> 
     208        [Test] 
     209        public void TestHttpPostedFileIsValid() 
     210        { 
     211            Assert.That(Reflections.HttpPostedFile.IsValid, Is.True); 
     212        } 
     213 
     214        /// <summary> 
     215        /// <see cref="Reflections.HttpPostedFile"/> のインスタンスが作成できるかのテストです。 
     216        /// </summary> 
     217        [Test] 
     218        public void TestHttpPostedFileCreateInstance() 
     219        { 
     220            Assert.That( 
     221                Reflections.HttpPostedFile.CreateInstance( 
     222                    "file.txt", 
     223                    "text/plain", 
     224                    Reflections.HttpInputStream.CreateInstance( 
     225                        Reflections.HttpRawUploadedContent.CreateInstance(new[] { (byte)1, (byte)2, }), 
     226                        0, 
     227                        2)), 
     228                Is.Not.Null); 
     229        } 
     230 
     231        /// <summary> 
     232        /// <see cref="Reflections.HttpPostedFile"/> で作成したインスタンスの動作が正しいかのテストです。 
     233        /// </summary> 
     234        [Test] 
     235        public void TestHttpPostedFileBehaviors() 
     236        { 
     237            const string FileName = "file.txt"; 
     238            const string ContentType = "text/plain"; 
     239 
     240            HttpPostedFile httpPostedFile 
     241                = Reflections.HttpPostedFile.CreateInstance( 
     242                    FileName, 
     243                    ContentType, 
     244                    Reflections.HttpInputStream.CreateInstance( 
     245                        Reflections.HttpRawUploadedContent.CreateInstance(new[] { (byte)1, (byte)2, }), 
     246                        0, 
     247                        2)); 
     248            Assert.That(httpPostedFile, Is.Not.Null, "CreateInstance"); 
     249            Assert.That(httpPostedFile.FileName, Is.EqualTo(FileName), "FileName"); 
     250            Assert.That(httpPostedFile.ContentType, Is.EqualTo(ContentType), "ContentType"); 
     251            Assert.That(httpPostedFile.ContentLength, Is.EqualTo(2), "ContentLength"); 
     252            Assert.That(httpPostedFile.InputStream.Length, Is.EqualTo(2), "InputStream.Length"); 
     253            Assert.That(httpPostedFile.InputStream.Position, Is.EqualTo(0), "InputStream.Position:1"); 
     254            Assert.That(httpPostedFile.InputStream.ReadByte(), Is.EqualTo(1), "InputStream.Read:1"); 
     255            Assert.That(httpPostedFile.InputStream.Position, Is.EqualTo(1), "InputStream.Position:2"); 
     256            Assert.That(httpPostedFile.InputStream.ReadByte(), Is.EqualTo(2), "InputStream.Read:2"); 
     257            Assert.That(httpPostedFile.InputStream.Position, Is.EqualTo(2), "InputStream.Position:3"); 
     258            Assert.That(httpPostedFile.InputStream.ReadByte(), Is.EqualTo(-1), "InputStream.Read:3"); 
     259        } 
     260 
     261 
     262        /// <summary> 
    86263        /// <see cref="Reflections.FormsAuthentication.GetCookieSameSite()"/> のテストです。 
    87264        /// </summary> 
    … …  
    130307        } 
    131308 
     309 
    132310        /// <summary> 
    133311        /// <see cref="Reflections.WebControl"/> が使用出来るかのテストです。 
    … …  
    140318 
    141319        /// <summary> 
    142         /// <see cref="Reflections.Control"/> の <c>disabledDirty</c> へアクセスするテストです。 
     320        /// <see cref="Reflections.WebControl"/> の <c>disabledDirty</c> へアクセスするテストです。 
    143321        /// </summary> 
    144322        [Test] 
    … …  
    162340            Reflections.WebControl.SetWebControlFlags(control, Bit); 
    163341        } 
     342 
    164343 
    165344        /// <summary> 
    … …  
    188367        } 
    189368 
     369 
    190370        /// <summary> 
    191371        /// <see cref="Reflections.ScriptManager"/> が使用出来るかのテストです。 
    … …  
    197377        } 
    198378 
     379 
    199380        /// <summary> 
    200381        /// <see cref="Reflections.PageRequestManager"/> が使用出来るかのテストです。 
    … …  
    205386            Assert.That(Reflections.PageRequestManager.IsValid, Is.True); 
    206387        } 
     388 
    207389 
    208390        /// <summary> 
    … …  
    233415        } 
    234416 
     417 
    235418        /// <summary> 
    236419        /// <see cref="Reflections.RadioButtonList"/> が使用出来るかのテストです。 
※ 詳しい使い方は TracChangeset を参照してください。