SharpCifs.Smb.SmbTransport.Send C# (CSharp) Méthode

        internal virtual void Send(ServerMessageBlock request, ServerMessageBlock response
            )
        {
            Connect();
            request.Flags2 |= Flags2;
            request.UseUnicode = UseUnicode;
            request.Response = response;
            if (request.Digest == null)
            {
                request.Digest = Digest;
            }
            try
            {
                if (response == null)
                {
                    DoSend0(request);
                    return;
                }
                if (request is SmbComTransaction)
                {
                    response.Command = request.Command;
                    SmbComTransaction req = (SmbComTransaction)request;
                    SmbComTransactionResponse resp = (SmbComTransactionResponse)response;
                    req.MaxBufferSize = SndBufSize;
                    resp.Reset();
                    try
                    {
                        BufferCache.GetBuffers(req, resp);
                        req.Current();
                        if (req.MoveNext())
                        {
                            SmbComBlankResponse interim = new SmbComBlankResponse();
                            Sendrecv(req, interim, SmbConstants.ResponseTimeout);
                            if (interim.ErrorCode != 0)
                            {
                                CheckStatus(req, interim);
                            }
                            req.Current();
                        }
                        else
                        {
                            MakeKey(req);
                        }
                        lock (this)
                        {
                            response.Received = false;
                            resp.IsReceived = false;
                            try
                            {
                                ResponseMap.Put(req, resp);
                                do
                                {
                                    DoSend0(req);
                                }
                                while (req.MoveNext() && req.Current() != null);
                                long timeout = SmbConstants.ResponseTimeout;
                                resp.Expiration = Runtime.CurrentTimeMillis() + timeout;
                                while (resp.MoveNext())
                                {
                                    Runtime.Wait(this, timeout);
                                    timeout = resp.Expiration - Runtime.CurrentTimeMillis();
                                    if (timeout <= 0)
                                    {
                                        throw new TransportException(this + " timedout waiting for response to " + req);
                                    }
                                }
                                if (response.ErrorCode != 0)
                                {
                                    CheckStatus(req, resp);
                                }
                            }
                            catch (Exception ie)
                            {
                                if (ie is SmbException)
                                {
                                    throw;
                                }
                                else
                                {
                                    throw new TransportException(ie);                                    
                                }
                            }
                            finally
                            {
                                //Sharpen.Collections.Remove<Hashtable, SmbComTransaction>(response_map, req);
                                ResponseMap.Remove(req);
                            }
                        }
                    }
                    finally
                    {
                        BufferCache.ReleaseBuffer(req.TxnBuf);
                        BufferCache.ReleaseBuffer(resp.TxnBuf);
                    }
                }
                else
                {
                    response.Command = request.Command;
                    Sendrecv(request, response, SmbConstants.ResponseTimeout);
                }
            }
            catch (SmbException se)
            {
                throw;
            }
            catch (IOException ioe)
            {
                throw new SmbException(ioe.Message, ioe);
            }
            CheckStatus(request, response);
        }

 /// <exception cref="SharpCifs.Smb.SmbException"></exception>
 internal void Send(ServerMessageBlock request, ServerMessageBlock response)
 {
     lock (Transport())
     {
         if (response != null)
         {
             response.Received = false;
         }
         Expiration = Runtime.CurrentTimeMillis() + SmbConstants.SoTimeout;
         SessionSetup(request, response);
         if (response != null && response.Received)
         {
             return;
         }
         if (request is SmbComTreeConnectAndX)
         {
             SmbComTreeConnectAndX tcax = (SmbComTreeConnectAndX)request;
             if (NetbiosName != null && tcax.path.EndsWith("\\IPC$"))
             {
                 tcax.path = "\\\\" + NetbiosName + "\\IPC$";
             }
         }
         request.Uid  = Uid;
         request.Auth = Auth;
         try
         {
             transport.Send(request, response);
         }
         catch (SmbException se)
         {
             if (request is SmbComTreeConnectAndX)
             {
                 Logoff(true);
             }
             request.Digest = null;
             throw;
         }
     }
 }