Asynchronous uploading problem with FtpWebRequest

[Deep]

dear friends
I have to write a program of multiple upload of images.

I have used the concept of Asynchronous through net. But It is giving
error. Here first I am using single image file upload.

when it reaches to this line
response = (FtpWebResponse)state.Request.EndGetResponse(ar);
It is written in function EndGetResponseCallback

then it is giving error
The remote server returned an error: (550) File unavailable (e.g.,
file not found, no access).

please help me it is very urgent.

I am showing my whole code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Threading;
using System.IO;


namespace AsynchronousFtpUpLoader
{
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
{
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 = @"C:\data\1.jpg";
FtpState state = new FtpState();
FtpWebRequest request =
(FtpWebRequest)WebRequest.Create("ftp://192.168.12.19/vivekNew/
vivek");
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("uninumber",
"chetu123");

// 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();
}
}

}
}


Thanks in advance

 

[Peter Duniho]

dear friends
I have to write a program of multiple upload of images.

I have used the concept of Asynchronous through net. But It is giving
error. Here first I am using single image file upload.

when it reaches to this line
response = (FtpWebResponse)state.Request.EndGetResponse(ar);
It is written in function EndGetResponseCallback

then it is giving error
The remote server returned an error: (550) File unavailable (e.g.,
file not found, no access).

The error seems pretty specific, among other things "no access" can
cause it. In any case, it's an error from the FTP server, with the code
550. So you should be looking at the request that's being sent to the
server and why it's responding the way it is.

It's not really a C# question anyway, but if you're going to get help on
the question at all here, you'd have to provide a true
concise-but-complete code example that reliably reproduces the problem.
That would include some minimal FTP server that can be used to test
the code and which anyone else has access to.

Pete