FtpWebRequest Klas

Definitie

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

Overname

Object

MarshalByRefObject

WebRequest

FtpWebRequest

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u een bestand van een FTP-server verwijdert.

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;
}

In het volgende codevoorbeeld ziet u hoe u een bestand downloadt van een FTP-server met behulp van de WebClient klasse.

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;
}

In het volgende codevoorbeeld ziet u hoe u asynchrone bewerkingen gebruikt om een bestand te uploaden naar een 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();
            }
        }
    }
}

Opmerkingen

Gebruik de Create methode om een instantie van FtpWebRequestte verkrijgen. U kunt de WebClient klasse ook gebruiken om informatie van een FTP-server te uploaden en te downloaden. Wanneer u een van deze methoden gebruikt, geeft u een netwerkresource op die gebruikmaakt van het FTP-schema (bijvoorbeeld "ftp://contoso.com") biedt de FtpWebRequest klasse de mogelijkheid om programmatisch te communiceren met FTP-servers.

De URI kan relatief of absoluut zijn. Als de URI van het formulier "ftp://contoso.com/%2fpath" is (%2f is een escaped '/'), is de URI absoluut en is de huidige map /path. Als de URI echter van het formulier "ftp://contoso.com/path" is, meldt .NET Framework zich eerst aan bij de FTP-server (met behulp van de gebruikersnaam en het wachtwoord die is ingesteld door de eigenschap Credentials), wordt de huidige map ingesteld op <UserLoginDirectory>/path.

U moet een geldige gebruikersnaam en een geldig wachtwoord hebben voor de server of de server moet anonieme aanmelding toestaan. U kunt de referenties opgeven die worden gebruikt om verbinding te maken met de server door de Credentials eigenschap in te stellen of u kunt deze opnemen in het UserInfo gedeelte van de URI die aan de Create methode is doorgegeven. Als u informatie opneemt UserInfo in de URI, wordt de Credentials eigenschap ingesteld op een nieuwe netwerkreferentie met de opgegeven gebruikersnaam en wachtwoordgegevens.

U moet toegang hebben WebPermission tot de FTP-resource. Anders wordt er een SecurityException uitzondering gegenereerd.

Geef de FTP-opdracht op die naar de server moet worden verzonden door de Method eigenschap in te stellen op een waarde die in de WebRequestMethods.Ftp structuur is gedefinieerd. Als u tekstgegevens wilt verzenden, wijzigt u de eigenschap van de UseBinary standaardwaarde (true) in false. Zie voor meer informatie en beperkingen Method.

Wanneer u een FtpWebRequest object gebruikt om een bestand te uploaden naar een server, moet u de bestandsinhoud naar de aanvraagstroom schrijven die is verkregen door de methode of de GetRequestStream asynchrone tegenhangers, de BeginGetRequestStream en EndGetRequestStream methoden aan te roepen. U moet naar de stream schrijven en de stream sluiten voordat u de aanvraag verzendt.

Aanvragen worden naar de server verzonden door de GetResponse methode of de asynchrone tegenhangers, de BeginGetResponse en EndGetResponse methoden aan te roepen. Wanneer de aangevraagde bewerking is voltooid, wordt een FtpWebResponse object geretourneerd. Het FtpWebResponse object geeft de status van de bewerking en alle gegevens die van de server zijn gedownload.

U kunt een time-outwaarde instellen voor lezen of schrijven naar de server met behulp van de ReadWriteTimeout eigenschap. Als de time-outperiode wordt overschreden, genereert de aanroepmethode een WebException met WebExceptionStatus de waarde ingesteld op Timeout.

Bij het downloaden van een bestand vanaf een FTP-server, als de opdracht is geslaagd, is de inhoud van het aangevraagde bestand beschikbaar in de stream van het antwoordobject. U kunt deze stream openen door de GetResponseStream methode aan te roepen. Zie FtpWebResponse voor meer informatie.

Als de Proxy eigenschap is ingesteld, rechtstreeks of in een configuratiebestand, wordt communicatie met de FTP-server uitgevoerd via de opgegeven proxy. Als de opgegeven proxy een HTTP-proxy is, worden alleen de DownloadFile, ListDirectoryen ListDirectoryDetails opdrachten ondersteund.

Alleen gedownloade binaire inhoud wordt in de cache opgeslagen; dat wil gezegd: inhoud die wordt ontvangen met behulp van de DownloadFile opdracht, waarbij de UseBinary eigenschap is ingesteld op true.

Meerdere FtpWebRequests hergebruiken bestaande verbindingen, indien mogelijk.

Zie RFC 959: File Transfer Protocol voor meer informatie over het FTP-protocol.

Zie ook

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