FtpWebRequest Klass

Definition

public ref class FtpWebRequest sealed : System::Net::WebRequest

public sealed class FtpWebRequest : System.Net.WebRequest

type FtpWebRequest = class
    inherit WebRequest

Public NotInheritable Class FtpWebRequest
Inherits WebRequest

Arv

Object

MarshalByRefObject

WebRequest

FtpWebRequest

Exempel

I följande kodexempel visas hur du tar bort en fil från en FTP-server.

public static bool DeleteFileOnServer(Uri serverUri)
{
    // The serverUri parameter should use the ftp:// scheme.
    // It contains the name of the server file that is to be deleted.
    // Example: ftp://contoso.com/someFile.txt.
    //

    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
    request.Method = WebRequestMethods.Ftp.DeleteFile;

    FtpWebResponse response = (FtpWebResponse) request.GetResponse();
    Console.WriteLine("Delete status: {0}",response.StatusDescription);
    response.Close();
    return true;
}

Följande kodexempel visar hur du laddar ned en fil från en FTP-server med hjälp WebClient av klassen .

public static bool DisplayFileFromServer(Uri serverUri)
{
    // The serverUri parameter should start with the ftp:// scheme.
    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    WebClient request = new WebClient();

    // This example assumes the FTP site uses anonymous logon.
    request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");
    try
    {
        byte [] newFileData = request.DownloadData (serverUri.ToString());
        string fileString = System.Text.Encoding.UTF8.GetString(newFileData);
        Console.WriteLine(fileString);
    }
    catch (WebException e)
    {
        Console.WriteLine(e.ToString());
    }
    return true;
}

Följande kodexempel visar hur du använder asynkrona åtgärder för att ladda upp en fil till en FTP-server.

using System;
using System.Net;
using System.Threading;

using System.IO;
namespace Examples.System.Net
{
    public class FtpState
    {
        private ManualResetEvent wait;
        private FtpWebRequest request;
        private string fileName;
        private Exception operationException = null;
        string status;

        public FtpState()
        {
            wait = new ManualResetEvent(false);
        }

        public ManualResetEvent OperationComplete
        {
            get {return wait;}
        }

        public FtpWebRequest Request
        {
            get {return request;}
            set {request = value;}
        }

        public string FileName
        {
            get {return fileName;}
            set {fileName = value;}
        }
        public Exception OperationException
        {
            get {return operationException;}
            set {operationException = value;}
        }
        public string StatusDescription
        {
            get {return status;}
            set {status = value;}
        }
    }
    public class AsynchronousFtpUpLoader
    {
        // Command line arguments are two strings:
        // 1. The url that is the name of the file being uploaded to the server.
        // 2. The name of the file on the local machine.
        //
        public static void Main(string[] args)
        {
            // Create a Uri instance with the specified URI string.
            // If the URI is not correctly formed, the Uri constructor
            // will throw an exception.
            ManualResetEvent waitObject;

            Uri target = new Uri (args[0]);
            string fileName = args[1];
            FtpState state = new FtpState();
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(target);
            request.Method = WebRequestMethods.Ftp.UploadFile;

            // This example uses anonymous logon.
            // The request is anonymous by default; the credential does not have to be specified.
            // The example specifies the credential only to
            // control how actions are logged on the server.

            request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

            // Store the request in the object that we pass into the
            // asynchronous operations.
            state.Request = request;
            state.FileName = fileName;

            // Get the event to wait on.
            waitObject = state.OperationComplete;

            // Asynchronously get the stream for the file contents.
            request.BeginGetRequestStream(
                new AsyncCallback (EndGetStreamCallback),
                state
            );

            // Block the current thread until all operations are complete.
            waitObject.WaitOne();

            // The operations either completed or threw an exception.
            if (state.OperationException != null)
            {
                throw state.OperationException;
            }
            else
            {
                Console.WriteLine("The operation completed - {0}", state.StatusDescription);
            }
        }
        private static void EndGetStreamCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;

            Stream requestStream = null;
            // End the asynchronous call to get the request stream.
            try
            {
                requestStream = state.Request.EndGetRequestStream(ar);
                // Copy the file contents to the request stream.
                const int bufferLength = 2048;
                byte[] buffer = new byte[bufferLength];
                int count = 0;
                int readBytes = 0;
                FileStream stream = File.OpenRead(state.FileName);
                do
                {
                    readBytes = stream.Read(buffer, 0, bufferLength);
                    requestStream.Write(buffer, 0, readBytes);
                    count += readBytes;
                }
                while (readBytes != 0);
                Console.WriteLine ("Writing {0} bytes to the stream.", count);
                // IMPORTANT: Close the request stream before sending the request.
                requestStream.Close();
                // Asynchronously get the response to the upload request.
                state.Request.BeginGetResponse(
                    new AsyncCallback (EndGetResponseCallback),
                    state
                );
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine("Could not get the request stream.");
                state.OperationException = e;
                state.OperationComplete.Set();
                return;
            }
        }

        // The EndGetResponseCallback method
        // completes a call to BeginGetResponse.
        private static void EndGetResponseCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;
            FtpWebResponse response = null;
            try
            {
                response = (FtpWebResponse) state.Request.EndGetResponse(ar);
                response.Close();
                state.StatusDescription = response.StatusDescription;
                // Signal the main application thread that
                // the operation is complete.
                state.OperationComplete.Set();
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine ("Error getting response.");
                state.OperationException = e;
                state.OperationComplete.Set();
            }
        }
    }
}

Kommentarer

Om du vill hämta en instans av FtpWebRequestanvänder du Create metoden . Du kan också använda WebClient klassen för att ladda upp och ladda ned information från en FTP-server. Om du använder någon av dessa metoder när du anger en nätverksresurs som använder FTP-schemat (till exempel "ftp://contoso.com") FtpWebRequest ger klassen möjlighet att programmatiskt interagera med FTP-servrar.

URI:n kan vara relativ eller absolut. Om URI:n är av formuläret "ftp://contoso.com/%2fpath" (%2f är en undantagen '/'), är URI:n absolut och den aktuella katalogen är /path. Om URI:n däremot är av formuläret "ftp://contoso.com/path" loggar först .NET Framework in på FTP-servern (med användarnamnet och lösenordet som anges av egenskapen Credentials) ställs den aktuella katalogen in på <UserLoginDirectory>/path.

Du måste ha ett giltigt användarnamn och lösenord för servern, annars måste servern tillåta anonym inloggning. Du kan ange de autentiseringsuppgifter som används för att ansluta till servern genom att ange Credentials egenskapen eller så kan du inkludera dem i den UserInfo del av URI:n som skickas Create till metoden. Om du inkluderar UserInfo information i URI Credentials :n anges egenskapen till en ny nätverksautentiseringsuppgift med angiven användarnamn och lösenordsinformation.

Du måste ha WebPermission åtkomst till FTP-resursen. Annars genereras ett SecurityException undantag.

Ange FTP-kommandot som ska skickas till servern genom att ange Method egenskapen till ett värde som definierats i WebRequestMethods.Ftp strukturen. Om du vill överföra textdata ändrar du UseBinary egenskapen från standardvärdet (true) till false. Mer information och begränsningar finns i Method.

När du använder ett FtpWebRequest objekt för att ladda upp en fil till en server måste du skriva filinnehållet till den begärandeström som erhålls genom att anropa GetRequestStream metoden eller dess asynkrona motsvarigheter, BeginGetRequestStream metoderna och EndGetRequestStream . Du måste skriva till strömmen och stänga strömmen innan du skickar begäran.

Begäranden skickas till servern genom att anropa GetResponse metoden eller dess asynkrona motsvarigheter, BeginGetResponse metoderna och EndGetResponse . När den begärda åtgärden är klar returneras ett FtpWebResponse objekt. Objektet FtpWebResponse ger status för åtgärden och alla data som laddas ned från servern.

Du kan ange ett timeout-värde för att läsa eller skriva till servern med hjälp ReadWriteTimeout av egenskapen . Om tidsgränsen överskrids genererar anropande metoden en WebException med WebExceptionStatus värdet Timeout.

När du laddar ned en fil från en FTP-server är innehållet i den begärda filen tillgängligt i svarsobjektets dataström om kommandot lyckades. Du kan komma åt den här strömmen genom att GetResponseStream anropa metoden. Mer information finns i FtpWebResponse.

Om egenskapen Proxy anges, antingen direkt eller i en konfigurationsfil, sker kommunikationen med FTP-servern via den angivna proxyn. Om den angivna proxyn är en HTTP-proxy stöds endast DownloadFilekommandona , ListDirectoryoch ListDirectoryDetails .

Endast nedladdat binärt innehåll cachelagras. d.v.s. innehåll som tagits emot med DownloadFile kommandot med UseBinary egenskapen inställd på true.

Flera FtpWebRequeståteranvänder befintliga anslutningar, om möjligt.

Mer information om FTP-protokollet finns i RFC 959: File Transfer Protocol.

Se även

• FtpWebResponse
• FtpStatusCode
• WebRequestMethods.Ftp
• WebRequest
• WebResponse
• WebClient