<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.9.1"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Proton DotNet: Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectalign" style="padding-left: 0.5em;">
   <div id="projectname">Proton DotNet
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.1 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
var searchBox = new SearchBox("searchBox", "search",false,'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceApache.html">Apache</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid.html">Qpid</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton.html">Proton</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Client.html">Client</a></li><li class="navelem"><a class="el" href="namespaceApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation.html">Implementation</a></li><li class="navelem"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html">ClientStreamReceiver</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#properties">Properties</a> &#124;
<a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p>Implements the streaming message receiver which allows for reading of large messages in smaller chunks. The API allows for multiple calls to receiver but any call that happens after a large message receives begins will be blocked until the previous large message is fully read and the next arrives.  
 <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver:</div>
<div class="dyncontent">
 <div class="center">
  <img src="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.png" usemap="#Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver_map" alt=""/>
  <map id="Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver_map" name="Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver_map">
<area href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType.html" alt="Apache.Qpid.Proton.Client.Implementation.ClientReceiverLinkType&lt; IStreamReceiver &gt;" shape="rect" coords="0,112,505,136"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html" title="A single AMQP stream receiver instance" alt="Apache.Qpid.Proton.Client.IStreamReceiver" shape="rect" coords="515,112,1020,136"/>
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html" alt="Apache.Qpid.Proton.Client.ILink&lt; IStreamReceiver &gt;" shape="rect" coords="515,56,1020,80"/>
  </map>
</div></div>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:a0036f882423bb0f699249e1dd59c54fa"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a0036f882423bb0f699249e1dd59c54fa">Receive</a> ()</td></tr>
<tr class="memdesc:a0036f882423bb0f699249e1dd59c54fa"><td class="mdescLeft">&#160;</td><td class="mdescRight">Blocking receive method that waits forever for the remote to provide some or all of a delivery for consumption. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a0036f882423bb0f699249e1dd59c54fa">More...</a><br /></td></tr>
<tr class="separator:a0036f882423bb0f699249e1dd59c54fa"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad081e0d7bdc8a712c9b9165477f58cbf"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#ad081e0d7bdc8a712c9b9165477f58cbf">TryReceive</a> ()</td></tr>
<tr class="memdesc:ad081e0d7bdc8a712c9b9165477f58cbf"><td class="mdescLeft">&#160;</td><td class="mdescRight">Non-blocking receive method that either returns a delivery is one is immediately available or returns null if none is currently at hand. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#ad081e0d7bdc8a712c9b9165477f58cbf">More...</a><br /></td></tr>
<tr class="separator:ad081e0d7bdc8a712c9b9165477f58cbf"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac76ebc9820e4d2ef0f319fcea2a36174"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#ac76ebc9820e4d2ef0f319fcea2a36174">Receive</a> (TimeSpan timeout)</td></tr>
<tr class="memdesc:ac76ebc9820e4d2ef0f319fcea2a36174"><td class="mdescLeft">&#160;</td><td class="mdescRight">Blocking receive method that waits for the specified time period for the remote to provide a delivery for consumption before returning null if none was received. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#ac76ebc9820e4d2ef0f319fcea2a36174">More...</a><br /></td></tr>
<tr class="separator:ac76ebc9820e4d2ef0f319fcea2a36174"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a28f1d3b68559545044fd2e5df335d603"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a28f1d3b68559545044fd2e5df335d603">ReceiveAsync</a> ()</td></tr>
<tr class="memdesc:a28f1d3b68559545044fd2e5df335d603"><td class="mdescLeft">&#160;</td><td class="mdescRight">Asynchronous receive method that waits forever for the remote to provide a delivery for consumption and when a delivery is available the returned Task will be completed. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a28f1d3b68559545044fd2e5df335d603">More...</a><br /></td></tr>
<tr class="separator:a28f1d3b68559545044fd2e5df335d603"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:afb139cf8da8cd335d1aede33e1c34695"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#afb139cf8da8cd335d1aede33e1c34695">TryReceiveAsync</a> ()</td></tr>
<tr class="memdesc:afb139cf8da8cd335d1aede33e1c34695"><td class="mdescLeft">&#160;</td><td class="mdescRight">Asynchronous receive method that returns a Task which will be completed either with a currently available delivery or with null to indicate there are no queued deliveries. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#afb139cf8da8cd335d1aede33e1c34695">More...</a><br /></td></tr>
<tr class="separator:afb139cf8da8cd335d1aede33e1c34695"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5381fe98d42d5cc217e076f614ad41b2"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a5381fe98d42d5cc217e076f614ad41b2">ReceiveAsync</a> (TimeSpan timeout)</td></tr>
<tr class="memdesc:a5381fe98d42d5cc217e076f614ad41b2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Asynchronous receive method that returns a Task that will be completed after the specified time period if the remote to provides a delivery for consumption before completing with null if none was received. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives.  <a href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamReceiver.html#a5381fe98d42d5cc217e076f614ad41b2">More...</a><br /></td></tr>
<tr class="separator:a5381fe98d42d5cc217e076f614ad41b2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType.html">Apache.Qpid.Proton.Client.Implementation.ClientReceiverLinkType&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:a722376c76c5d8d719917a2c5323b4d46 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a722376c76c5d8d719917a2c5323b4d46"></a>
LinkType&#160;</td><td class="memItemRight" valign="bottom"><b>AddCredit</b> (uint credit)</td></tr>
<tr class="separator:a722376c76c5d8d719917a2c5323b4d46 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3aa9a3815d45407f9aad75b41d890622 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a3aa9a3815d45407f9aad75b41d890622"></a>
Task&lt; LinkType &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>AddCreditAsync</b> (uint credit)</td></tr>
<tr class="separator:a3aa9a3815d45407f9aad75b41d890622 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6253ce91bde4205a61b515c86131ff84 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a6253ce91bde4205a61b515c86131ff84"></a>
LinkType&#160;</td><td class="memItemRight" valign="bottom"><b>Drain</b> ()</td></tr>
<tr class="separator:a6253ce91bde4205a61b515c86131ff84 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a300dbe8e339b04c3431498452bc76048 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a300dbe8e339b04c3431498452bc76048"></a>
Task&lt; LinkType &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>DrainAsync</b> ()</td></tr>
<tr class="separator:a300dbe8e339b04c3431498452bc76048 inherit pub_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">Apache.Qpid.Proton.Client.IStreamReceiver</a></td></tr>
<tr class="memitem:a033b2e0a45729b143241e6eba1dbac64 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">IStreamReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a033b2e0a45729b143241e6eba1dbac64">AddCredit</a> (uint credit)</td></tr>
<tr class="memdesc:a033b2e0a45729b143241e6eba1dbac64 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Adds credit to the Receiver link for use when there receiver has not been configured with with a credit window. When credit window is configured credit replenishment is automatic and calling this method will result in an exception indicating that the operation is invalid.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a033b2e0a45729b143241e6eba1dbac64">More...</a><br /></td></tr>
<tr class="separator:a033b2e0a45729b143241e6eba1dbac64 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af6385b8e4ed74534804cb9c86cc83c79 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">IStreamReceiver</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#af6385b8e4ed74534804cb9c86cc83c79">AddCreditAsync</a> (uint credit)</td></tr>
<tr class="memdesc:af6385b8e4ed74534804cb9c86cc83c79 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Asynchronously Adds credit to the Receiver link for use when there receiver has not been configured with with a credit window. When credit window is configured credit replenishment is automatic and calling this method will result in an exception indicating that the operation is invalid.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#af6385b8e4ed74534804cb9c86cc83c79">More...</a><br /></td></tr>
<tr class="separator:af6385b8e4ed74534804cb9c86cc83c79 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3c872179270efff2e9fbdee25fa8fd7d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">IStreamReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a3c872179270efff2e9fbdee25fa8fd7d">Drain</a> ()</td></tr>
<tr class="memdesc:a3c872179270efff2e9fbdee25fa8fd7d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Requests the remote to drain previously granted credit for this receiver link. The remote will either send all available deliveries up to the currently granted link credit or will report it has none to send an link credit will be set to zero. This method will block until the remote answers the drain request or the configured drain timeout expires.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a3c872179270efff2e9fbdee25fa8fd7d">More...</a><br /></td></tr>
<tr class="separator:a3c872179270efff2e9fbdee25fa8fd7d inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a080b4e4f74fe2d03b6fd68c461fe44dd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">IStreamReceiver</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a080b4e4f74fe2d03b6fd68c461fe44dd">DrainAsync</a> ()</td></tr>
<tr class="memdesc:a080b4e4f74fe2d03b6fd68c461fe44dd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">Requests the remote to drain previously granted credit for this receiver link. The remote will either send all available deliveries up to the currently granted link credit or will report it has none to send an link credit will be set to zero. The caller can wait on the returned task which will be signalled either after the remote reports drained or once the configured drain timeout is reached.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a080b4e4f74fe2d03b6fd68c461fe44dd">More...</a><br /></td></tr>
<tr class="separator:a080b4e4f74fe2d03b6fd68c461fe44dd inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td colspan="2" onclick="javascript:toggleInherit('pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink')"><img src="closed.png" alt="-"/>&#160;Public Member Functions inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html">Apache.Qpid.Proton.Client.ILink&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:a228d7c08a2e78d41ebc8742f57281417 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a228d7c08a2e78d41ebc8742f57281417">Close</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IErrorCondition.html">IErrorCondition</a> error=null)</td></tr>
<tr class="memdesc:a228d7c08a2e78d41ebc8742f57281417 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiates a close of the link and awaits a response from the remote that indicates completion of the close operation. If the response from the remote exceeds the configure close timeout the method returns after cleaning up the link resources.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a228d7c08a2e78d41ebc8742f57281417">More...</a><br /></td></tr>
<tr class="separator:a228d7c08a2e78d41ebc8742f57281417 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4caa12237d5e8fc736bc1ba0c541f47f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a4caa12237d5e8fc736bc1ba0c541f47f">Detach</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IErrorCondition.html">IErrorCondition</a> error=null)</td></tr>
<tr class="memdesc:a4caa12237d5e8fc736bc1ba0c541f47f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiates a detach of the link and awaits a response from the remote that indicates completion of the detach operation. If the response from the remote exceeds the configure close timeout the method returns after cleaning up the link resources.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a4caa12237d5e8fc736bc1ba0c541f47f">More...</a><br /></td></tr>
<tr class="separator:a4caa12237d5e8fc736bc1ba0c541f47f inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a513455e79843acd6dc01952853a2a1eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">Task&lt; Role &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a513455e79843acd6dc01952853a2a1eb">CloseAsync</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IErrorCondition.html">IErrorCondition</a> error=null)</td></tr>
<tr class="memdesc:a513455e79843acd6dc01952853a2a1eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiates a close of the link and a Task that allows the caller to await or poll for the response from the remote that indicates completion of the close operation. If the response from the remote exceeds the configure close timeout the sender will be cleaned up and the Task signalled indicating completion.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a513455e79843acd6dc01952853a2a1eb">More...</a><br /></td></tr>
<tr class="separator:a513455e79843acd6dc01952853a2a1eb inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aad772a1fb032480d67568d171f3c6ab8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">Task&lt; Role &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#aad772a1fb032480d67568d171f3c6ab8">DetachAsync</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IErrorCondition.html">IErrorCondition</a> error=null)</td></tr>
<tr class="memdesc:aad772a1fb032480d67568d171f3c6ab8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initiates a detach of the link and a Task that allows the caller to await or poll for the response from the remote that indicates completion of the detach operation. If the response from the remote exceeds the configure close timeout the sender will be cleaned up and the Task signalled indicating completion.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#aad772a1fb032480d67568d171f3c6ab8">More...</a><br /></td></tr>
<tr class="separator:aad772a1fb032480d67568d171f3c6ab8 inherit pub_methods_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="properties"></a>
Properties</h2></td></tr>
<tr class="memitem:af83bfb3134d3591e1a2a864a4296c35c"><td class="memItemLeft" align="right" valign="top"><a id="af83bfb3134d3591e1a2a864a4296c35c"></a>
override <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">IStreamReceiver</a>&#160;</td><td class="memItemRight" valign="bottom"><b>Self</b><code> [get]</code></td></tr>
<tr class="separator:af83bfb3134d3591e1a2a864a4296c35c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td colspan="2" onclick="javascript:toggleInherit('properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType.html">Apache.Qpid.Proton.Client.Implementation.ClientReceiverLinkType&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:aa568647ccbbfb34bd05a6d5ab9616248 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="aa568647ccbbfb34bd05a6d5ab9616248"></a>
virtual int&#160;</td><td class="memItemRight" valign="bottom"><b>QueuedDeliveries</b><code> [get]</code></td></tr>
<tr class="separator:aa568647ccbbfb34bd05a6d5ab9616248 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8268aba3505a95efb36cd5518b15cd22 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a8268aba3505a95efb36cd5518b15cd22"></a>
abstract LinkType&#160;</td><td class="memItemRight" valign="bottom"><b>Self</b><code> [get]</code></td></tr>
<tr class="separator:a8268aba3505a95efb36cd5518b15cd22 inherit properties_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html">Apache.Qpid.Proton.Client.IStreamReceiver</a></td></tr>
<tr class="memitem:a6ff778e6c729c6ef4e2e8793f90f6c98 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a6ff778e6c729c6ef4e2e8793f90f6c98">QueuedDeliveries</a><code> [get]</code></td></tr>
<tr class="memdesc:a6ff778e6c729c6ef4e2e8793f90f6c98 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="mdescLeft">&#160;</td><td class="mdescRight">A count of the currently queued deliveries which can be read immediately without blocking a call to receive.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a6ff778e6c729c6ef4e2e8793f90f6c98">More...</a><br /></td></tr>
<tr class="separator:a6ff778e6c729c6ef4e2e8793f90f6c98 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td colspan="2" onclick="javascript:toggleInherit('properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink')"><img src="closed.png" alt="-"/>&#160;Properties inherited from <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html">Apache.Qpid.Proton.Client.ILink&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:a1d69faec32b3de693e22e6279ba158ac inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IClient.html">IClient</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a1d69faec32b3de693e22e6279ba158ac">Client</a><code> [get]</code></td></tr>
<tr class="memdesc:a1d69faec32b3de693e22e6279ba158ac inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the parent client instance that hosts this link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a1d69faec32b3de693e22e6279ba158ac">More...</a><br /></td></tr>
<tr class="separator:a1d69faec32b3de693e22e6279ba158ac inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acb317c6a972e1ba829e993ad700132ce inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IConnection.html">IConnection</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#acb317c6a972e1ba829e993ad700132ce">Connection</a><code> [get]</code></td></tr>
<tr class="memdesc:acb317c6a972e1ba829e993ad700132ce inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the parent connection instance that hosts this link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#acb317c6a972e1ba829e993ad700132ce">More...</a><br /></td></tr>
<tr class="separator:acb317c6a972e1ba829e993ad700132ce inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a627cdff32fb7042573e3c810919f3e14 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ISession.html">ISession</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a627cdff32fb7042573e3c810919f3e14">Session</a><code> [get]</code></td></tr>
<tr class="memdesc:a627cdff32fb7042573e3c810919f3e14 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the parent session instance that created this link.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a627cdff32fb7042573e3c810919f3e14">More...</a><br /></td></tr>
<tr class="separator:a627cdff32fb7042573e3c810919f3e14 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2006624670b65d75c368ea4c6701355d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">string&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a2006624670b65d75c368ea4c6701355d">Address</a><code> [get]</code></td></tr>
<tr class="memdesc:a2006624670b65d75c368ea4c6701355d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the address that the link instance will send message objects to. The value returned from this method is controlled by the configuration that was used to create the link. </p><ul>
<li>
If the link is configured as an anonymous link then this method returns null.   </li>
<li>
If the link was created with the dynamic link methods then the method will return the dynamically created address once the remote has attached its end of the link link. Due to the need to await the remote peer to populate the dynamic address this method will block until the open of the link link has completed.   </li>
<li>
If neither of the above is true then the address returned is the address passed to the original address value passed to one of the open link methods.   </li>
</ul>
 <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a2006624670b65d75c368ea4c6701355d">More...</a><br /></td></tr>
<tr class="separator:a2006624670b65d75c368ea4c6701355d inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9f1623883c42f02a1bb990fd91cdfff8 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ISource.html">ISource</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a9f1623883c42f02a1bb990fd91cdfff8">Source</a><code> [get]</code></td></tr>
<tr class="memdesc:a9f1623883c42f02a1bb990fd91cdfff8 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an immutable view of the remote Source object assigned to this link link. If the attach has not completed yet this method will block to await the attach response which carries the remote source.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a9f1623883c42f02a1bb990fd91cdfff8">More...</a><br /></td></tr>
<tr class="separator:a9f1623883c42f02a1bb990fd91cdfff8 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a697531042f2cafdbde67990c3a1d08f5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ITarget.html">ITarget</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a697531042f2cafdbde67990c3a1d08f5">Target</a><code> [get]</code></td></tr>
<tr class="memdesc:a697531042f2cafdbde67990c3a1d08f5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns an immutable view of the remote Target object assigned to this link link. If the attach has not completed yet this method will block to await the attach response which carries the remote target.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a697531042f2cafdbde67990c3a1d08f5">More...</a><br /></td></tr>
<tr class="separator:a697531042f2cafdbde67990c3a1d08f5 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a333a8e9f74d1630eff1ed374aabe0b88 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">IReadOnlyDictionary&lt; string, object &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a333a8e9f74d1630eff1ed374aabe0b88">Properties</a><code> [get]</code></td></tr>
<tr class="memdesc:a333a8e9f74d1630eff1ed374aabe0b88 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the properties that the remote provided upon successfully opening the link. If the open has not completed yet this method will block to await the open response which carries the remote properties. If the remote provides no properties this method will return null.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a333a8e9f74d1630eff1ed374aabe0b88">More...</a><br /></td></tr>
<tr class="separator:a333a8e9f74d1630eff1ed374aabe0b88 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a95fdfaad4b7b09dd8226d5adeac91271 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">IReadOnlyCollection&lt; string &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a95fdfaad4b7b09dd8226d5adeac91271">OfferedCapabilities</a><code> [get]</code></td></tr>
<tr class="memdesc:a95fdfaad4b7b09dd8226d5adeac91271 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the offered capabilities that the remote provided upon successfully opening the link. If the open has not completed yet this method will block to await the open response which carries the remote offered capabilities. If the remote provides no offered capabilities this method will return null.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a95fdfaad4b7b09dd8226d5adeac91271">More...</a><br /></td></tr>
<tr class="separator:a95fdfaad4b7b09dd8226d5adeac91271 inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab953057eb2f7491aae452abac4168dbf inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">IReadOnlyCollection&lt; string &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#ab953057eb2f7491aae452abac4168dbf">DesiredCapabilities</a><code> [get]</code></td></tr>
<tr class="memdesc:ab953057eb2f7491aae452abac4168dbf inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the desired capabilities that the remote provided upon successfully opening the link. If the open has not completed yet this method will block to await the open response which carries the remote desired capabilities. If the remote provides no desired capabilities this method will return null.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#ab953057eb2f7491aae452abac4168dbf">More...</a><br /></td></tr>
<tr class="separator:ab953057eb2f7491aae452abac4168dbf inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a967c89aa8ef28800557af66c1b993d7c inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memItemLeft" align="right" valign="top">Task&lt; Role &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a967c89aa8ef28800557af66c1b993d7c">OpenTask</a><code> [get]</code></td></tr>
<tr class="memdesc:a967c89aa8ef28800557af66c1b993d7c inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="mdescLeft">&#160;</td><td class="mdescRight">When a link is created and returned to the client application it may not be remotely opened yet and if the client needs to wait for completion of the open before proceeding the open task can be fetched and waited upon.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html#a967c89aa8ef28800557af66c1b993d7c">More...</a><br /></td></tr>
<tr class="separator:a967c89aa8ef28800557af66c1b993d7c inherit properties_interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="inherited"></a>
Additional Inherited Members</h2></td></tr>
<tr class="inherit_header pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td colspan="2" onclick="javascript:toggleInherit('pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType')"><img src="closed.png" alt="-"/>&#160;Protected Member Functions inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType.html">Apache.Qpid.Proton.Client.Implementation.ClientReceiverLinkType&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:ac34cc93f2f72b916f6f92aa1fb3eb073 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="ac34cc93f2f72b916f6f92aa1fb3eb073"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>AsyncApplyDisposition</b> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Engine_1_1IIncomingDelivery.html">IIncomingDelivery</a> delivery, <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Types_1_1Transport_1_1IDeliveryState.html">Types.Transport.IDeliveryState</a> state, bool settle)</td></tr>
<tr class="separator:ac34cc93f2f72b916f6f92aa1fb3eb073 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a27a1bcb4cb7d78639de63e5b3039f3d1 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a27a1bcb4cb7d78639de63e5b3039f3d1"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><b>AsyncReplenishCreditIfNeeded</b> ()</td></tr>
<tr class="separator:a27a1bcb4cb7d78639de63e5b3039f3d1 inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1049e2ac6fd52720147dabc914b2628a inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a1049e2ac6fd52720147dabc914b2628a"></a>
virtual void&#160;</td><td class="memItemRight" valign="bottom"><b>ReplenishCreditIfNeeded</b> ()</td></tr>
<tr class="separator:a1049e2ac6fd52720147dabc914b2628a inherit pro_methods_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="inherit_header pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td colspan="2" onclick="javascript:toggleInherit('pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType')"><img src="closed.png" alt="-"/>&#160;Protected Attributes inherited from <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType.html">Apache.Qpid.Proton.Client.Implementation.ClientReceiverLinkType&lt; IStreamReceiver &gt;</a></td></tr>
<tr class="memitem:af7c17400753cf125e500330822487f16 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="af7c17400753cf125e500330822487f16"></a>
TaskCompletionSource&lt; LinkType &gt;&#160;</td><td class="memItemRight" valign="bottom"><b>drainingFuture</b></td></tr>
<tr class="separator:af7c17400753cf125e500330822487f16 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0a98c12a60376a7e27be633a8ae1f70e inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="a0a98c12a60376a7e27be633a8ae1f70e"></a>
readonly <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1ReceiverOptions.html">ReceiverOptions</a>&#160;</td><td class="memItemRight" valign="bottom"><b>options</b></td></tr>
<tr class="separator:a0a98c12a60376a7e27be633a8ae1f70e inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac9df7f1cfa19caf67b81cdf796391e56 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memItemLeft" align="right" valign="top"><a id="ac9df7f1cfa19caf67b81cdf796391e56"></a>
readonly string&#160;</td><td class="memItemRight" valign="bottom"><b>receiverId</b></td></tr>
<tr class="separator:ac9df7f1cfa19caf67b81cdf796391e56 inherit pro_attribs_classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientReceiverLinkType"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>Implements the streaming message receiver which allows for reading of large messages in smaller chunks. The API allows for multiple calls to receiver but any call that happens after a large message receives begins will be blocked until the previous large message is fully read and the next arrives. </p>
</div><h2 class="groupheader">Member Function Documentation</h2>
<a id="a0036f882423bb0f699249e1dd59c54fa"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a0036f882423bb0f699249e1dd59c54fa">&#9670;&nbsp;</a></span>Receive() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.Receive </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Blocking receive method that waits forever for the remote to provide some or all of a delivery for consumption. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<p>Receive calls will only grant credit on their own if a credit window is configured in the options which by default will have been configured. If the client application has not configured a credit window then this method won't grant or extend the credit window but will wait for a delivery regardless. The application needs to arrange for credit to be granted in that case. </p>
<dl class="section return"><dt>Returns</dt><dd>The next available delivery</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#afe48e9081c869ab6383eb1c97f56221f">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<a id="ac76ebc9820e4d2ef0f319fcea2a36174"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ac76ebc9820e4d2ef0f319fcea2a36174">&#9670;&nbsp;</a></span>Receive() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.Receive </td>
          <td>(</td>
          <td class="paramtype">TimeSpan&#160;</td>
          <td class="paramname"><em>timeout</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Blocking receive method that waits for the specified time period for the remote to provide a delivery for consumption before returning null if none was received. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<p>Receive calls will only grant credit on their own if a credit window is configured in the options which by default will have been configured. If the client application has not configured a credit window then this method won't grant or extend the credit window but will wait for a delivery regardless. The application needs to arrange for credit to be granted in that case. </p>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#afafacb836f4315c83652094b4b5f1c44">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<a id="a28f1d3b68559545044fd2e5df335d603"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a28f1d3b68559545044fd2e5df335d603">&#9670;&nbsp;</a></span>ReceiveAsync() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Task&lt;<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&gt; Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.ReceiveAsync </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Asynchronous receive method that waits forever for the remote to provide a delivery for consumption and when a delivery is available the returned Task will be completed. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<p>Receive calls will only grant credit on their own if a credit window is configured in the options which by default will have been configured. If the client application has not configured a credit window then this method won't grant or extend the credit window but will wait for a delivery regardless. The application needs to arrange for credit to be granted in that case. </p>
<dl class="section return"><dt>Returns</dt><dd>The next available delivery</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#aa4bf51c5e657d9dd9db0942585480d70">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<a id="a5381fe98d42d5cc217e076f614ad41b2"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5381fe98d42d5cc217e076f614ad41b2">&#9670;&nbsp;</a></span>ReceiveAsync() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Task&lt;<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&gt; Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.ReceiveAsync </td>
          <td>(</td>
          <td class="paramtype">TimeSpan&#160;</td>
          <td class="paramname"><em>timeout</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Asynchronous receive method that returns a Task that will be completed after the specified time period if the remote to provides a delivery for consumption before completing with null if none was received. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<p>Receive calls will only grant credit on their own if a credit window is configured in the options which by default will have been configured. If the client application has not configured a credit window then this method won't grant or extend the credit window but will wait for a delivery regardless. The application needs to arrange for credit to be granted in that case. </p>
<dl class="section return"><dt>Returns</dt><dd>The next available delivery or null if the time span elapses</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#ae074bfefea03e9b4d606d86964464c5d">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<a id="ad081e0d7bdc8a712c9b9165477f58cbf"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ad081e0d7bdc8a712c9b9165477f58cbf">&#9670;&nbsp;</a></span>TryReceive()</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a> Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.TryReceive </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Non-blocking receive method that either returns a delivery is one is immediately available or returns null if none is currently at hand. This method returns a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<dl class="section return"><dt>Returns</dt><dd>A delivery if one is immediately available or null if not</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#a27c9cf0583ee70b336903e613322ccca">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<a id="afb139cf8da8cd335d1aede33e1c34695"></a>
<h2 class="memtitle"><span class="permalink"><a href="#afb139cf8da8cd335d1aede33e1c34695">&#9670;&nbsp;</a></span>TryReceiveAsync()</h2>

<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">Task&lt;<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamDelivery.html">IStreamDelivery</a>&gt; Apache.Qpid.Proton.Client.Implementation.ClientStreamReceiver.TryReceiveAsync </td>
          <td>(</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Asynchronous receive method that returns a Task which will be completed either with a currently available delivery or with null to indicate there are no queued deliveries. The returned task completes with a streamed delivery instance that allows for consumption or the incoming delivery as it arrives. </p>
<dl class="section return"><dt>Returns</dt><dd>A Task that completes with a delivery if one is immediately available or null if not</dd></dl>

<p>Implements <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamReceiver.html#aa12df87826b5e34e5f7168de5ea761a5">Apache.Qpid.Proton.Client.IStreamReceiver</a>.</p>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>src/Proton.Client/Client/Implementation/ClientStreamReceiver.cs</li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.1
</small></address>
</body>
</html>
