public static IConnection End(IAsyncResult result)
{
EstablishConnectionAsyncResult thisPtr = AsyncResult.End <EstablishConnectionAsyncResult>(result);
if (TD.EstablishConnectionStopIsEnabled())
{
TD.EstablishConnectionStop(thisPtr.EventTraceActivity);
}
return(thisPtr.currentConnection);
}
public IConnection EstablishConnection(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
IConnection localRawConnection = null;
IConnection localUpgradedConnection = null;
bool localIsConnectionFromPool = true;
EventTraceActivity localEventTraceActivity = this.EventTraceActivity;
if (TD.EstablishConnectionStartIsEnabled())
{
TD.EstablishConnectionStart(localEventTraceActivity,
this.via != null ? this.via.AbsoluteUri : string.Empty);
}
// first try and use a connection from our pool (and use it if we successfully receive an ACK)
while (localIsConnectionFromPool)
{
localRawConnection = this.TakeConnection(timeoutHelper.RemainingTime());
if (localRawConnection == null)
{
localIsConnectionFromPool = false;
}
else
{
bool preambleSuccess = false;
try
{
localUpgradedConnection = AcceptPooledConnection(localRawConnection, ref timeoutHelper);
preambleSuccess = true;
break;
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
// CommmunicationException is ok since it was a cached connection of unknown state
}
catch (TimeoutException e)
{
if (TD.OpenTimeoutIsEnabled())
{
TD.OpenTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
// ditto for TimeoutException
}
finally
{
if (!preambleSuccess)
{
if (TD.ConnectionPoolPreambleFailedIsEnabled())
{
TD.ConnectionPoolPreambleFailed(localEventTraceActivity);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.FailedAcceptFromPool,
SR.GetString(
SR.TraceCodeFailedAcceptFromPool,
timeoutHelper.RemainingTime()));
}
// This cannot throw TimeoutException since isConnectionStillGood is false (doesn't attempt a Close).
this.connectionPool.ReturnConnection(connectionKey, localRawConnection, false, TimeSpan.Zero);
}
}
}
}
// if there isn't anything in the pool, we need to use a new connection
if (!localIsConnectionFromPool)
{
bool success = false;
TimeSpan connectTimeout = timeoutHelper.RemainingTime();
try
{
try
{
localRawConnection = this.connectionInitiator.Connect(this.via, connectTimeout);
}
catch (TimeoutException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateNewConnectionTimeoutException(
connectTimeout, e));
}
this.connectionInitiator = null;
localUpgradedConnection = AcceptPooledConnection(localRawConnection, ref timeoutHelper);
success = true;
}
finally
{
if (!success)
{
connectionKey = null;
if (localRawConnection != null)
{
localRawConnection.Abort();
}
}
}
}
SnapshotConnection(localUpgradedConnection, localRawConnection, localIsConnectionFromPool);
if (TD.EstablishConnectionStopIsEnabled())
{
TD.EstablishConnectionStop(localEventTraceActivity);
}
return(localUpgradedConnection);
}