<!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.IStreamSender Interface 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="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html">IStreamSender</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">Apache.Qpid.Proton.Client.IStreamSender Interface Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p>A single AMQP stream sender instance which can be used to transmit large message payloads to the remote without needing to load the full message contents into memory. The streaming sender will also provide flow control that attempts to provide additional safety values for out of memory situations.  
 <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#details">More...</a></p>
<div class="dynheader">
Inheritance diagram for Apache.Qpid.Proton.Client.IStreamSender:</div>
<div class="dyncontent">
 <div class="center">
  <img src="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.png" usemap="#Apache.Qpid.Proton.Client.IStreamSender_map" alt=""/>
  <map id="Apache.Qpid.Proton.Client.IStreamSender_map" name="Apache.Qpid.Proton.Client.IStreamSender_map">
<area href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1ILink.html" alt="Apache.Qpid.Proton.Client.ILink&lt; IStreamSender &gt;" shape="rect" coords="0,56,366,80"/>
<area href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html" title="Implements the stream sender using a stateful current outgoing message that prevents any sends other ..." alt="Apache.Qpid.Proton.Client.Implementation.ClientStreamSender" shape="rect" coords="0,168,366,192"/>
  </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:a2d8e285190348b38645ab3c731de9292"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a2d8e285190348b38645ab3c731de9292">Send&lt; T &gt;</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt; message, IDictionary&lt; string, object &gt; deliveryAnnotations=null)</td></tr>
<tr class="memdesc:a2d8e285190348b38645ab3c731de9292"><td class="mdescLeft">&#160;</td><td class="mdescRight">If no streaming send has been initiated and not yet completed then this method will send the given message immediately if there is credit available or blocks if the link has not yet been granted credit. If a send timeout has been configured then this method will throw a timed out error after that if the message cannot be sent.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a2d8e285190348b38645ab3c731de9292">More...</a><br /></td></tr>
<tr class="separator:a2d8e285190348b38645ab3c731de9292"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a082f33e2ca2b5d7c359503c2d8cf7deb"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a082f33e2ca2b5d7c359503c2d8cf7deb">SendAsync&lt; T &gt;</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt; message, IDictionary&lt; string, object &gt; deliveryAnnotations=null)</td></tr>
<tr class="memdesc:a082f33e2ca2b5d7c359503c2d8cf7deb"><td class="mdescLeft">&#160;</td><td class="mdescRight">If no streaming send has been initiated and not yet completed then this method will send the given message immediately if there is credit available or waits if the link has not yet been granted credit. If a send timeout has been configured then this method will fail the returned Task with a timed out error after that if the message cannot be sent. The returned Task will be completed once the message has been sent.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a082f33e2ca2b5d7c359503c2d8cf7deb">More...</a><br /></td></tr>
<tr class="separator:a082f33e2ca2b5d7c359503c2d8cf7deb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aad1fac7b9a02e987e981f9cc0cd8d4df"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#aad1fac7b9a02e987e981f9cc0cd8d4df">TrySend&lt; T &gt;</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt; message, IDictionary&lt; string, object &gt; deliveryAnnotations=null)</td></tr>
<tr class="memdesc:aad1fac7b9a02e987e981f9cc0cd8d4df"><td class="mdescLeft">&#160;</td><td class="mdescRight">If no streaming send has been initiated and not yet completed then this method will send the given message if credit is available or returns null if no credit has been granted to the link at the time of the send attempt.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#aad1fac7b9a02e987e981f9cc0cd8d4df">More...</a><br /></td></tr>
<tr class="separator:aad1fac7b9a02e987e981f9cc0cd8d4df"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acff11960d2b74020f33bcb5a909a6a2a"><td class="memItemLeft" align="right" valign="top">Task&lt; <a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a> &gt;&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#acff11960d2b74020f33bcb5a909a6a2a">TrySendAsync&lt; T &gt;</a> (<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt; message, IDictionary&lt; string, object &gt; deliveryAnnotations=null)</td></tr>
<tr class="memdesc:acff11960d2b74020f33bcb5a909a6a2a"><td class="mdescLeft">&#160;</td><td class="mdescRight">If no streaming send has been initiated and not yet completed then this method will send the given message if credit is available or completes the returned Task with null if no credit has been granted to the link at the time of the send attempt.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#acff11960d2b74020f33bcb5a909a6a2a">More...</a><br /></td></tr>
<tr class="separator:acff11960d2b74020f33bcb5a909a6a2a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a832f54231d28417973f019e93e1d1f46"><td class="memItemLeft" align="right" valign="top"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSenderMessage.html">IStreamSenderMessage</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a832f54231d28417973f019e93e1d1f46">BeginMessage</a> (IDictionary&lt; string, object &gt; deliveryAnnotations=null)</td></tr>
<tr class="memdesc:a832f54231d28417973f019e93e1d1f46"><td class="mdescLeft">&#160;</td><td class="mdescRight">Creates and returns a new streamable message that can be used by the caller to perform streaming sends of large message payload data. Only one streamed message can be active at a time so any successive calls to begin a new streaming message will throw an error to indicate that the previous instance has not yet been completed.  <a href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSender.html#a832f54231d28417973f019e93e1d1f46">More...</a><br /></td></tr>
<tr class="separator:a832f54231d28417973f019e93e1d1f46"><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; IStreamSender &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="inherited"></a>
Additional Inherited Members</h2></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; IStreamSender &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>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>A single AMQP stream sender instance which can be used to transmit large message payloads to the remote without needing to load the full message contents into memory. The streaming sender will also provide flow control that attempts to provide additional safety values for out of memory situations. </p>
</div><h2 class="groupheader">Member Function Documentation</h2>
<a id="a832f54231d28417973f019e93e1d1f46"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a832f54231d28417973f019e93e1d1f46">&#9670;&nbsp;</a></span>BeginMessage()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamSenderMessage.html">IStreamSenderMessage</a> Apache.Qpid.Proton.Client.IStreamSender.BeginMessage </td>
          <td>(</td>
          <td class="paramtype">IDictionary&lt; string, object &gt;&#160;</td>
          <td class="paramname"><em>deliveryAnnotations</em> = <code>null</code></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Creates and returns a new streamable message that can be used by the caller to perform streaming sends of large message payload data. Only one streamed message can be active at a time so any successive calls to begin a new streaming message will throw an error to indicate that the previous instance has not yet been completed. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">deliveryAnnotations</td><td>The optional delivery annotations to transmit with the message</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>This stream sender instance</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html#a9a1cd02cda7ac1a69f408d922a98521f">Apache.Qpid.Proton.Client.Implementation.ClientStreamSender</a>.</p>

</div>
</div>
<a id="a2d8e285190348b38645ab3c731de9292"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a2d8e285190348b38645ab3c731de9292">&#9670;&nbsp;</a></span>Send&lt; T &gt;()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a> Apache.Qpid.Proton.Client.IStreamSender.Send&lt; T &gt; </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt;&#160;</td>
          <td class="paramname"><em>message</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">IDictionary&lt; string, object &gt;&#160;</td>
          <td class="paramname"><em>deliveryAnnotations</em> = <code>null</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>If no streaming send has been initiated and not yet completed then this method will send the given message immediately if there is credit available or blocks if the link has not yet been granted credit. If a send timeout has been configured then this method will throw a timed out error after that if the message cannot be sent. </p>
<dl class="tparams"><dt>Template Parameters</dt><dd>
  <table class="tparams">
    <tr><td class="paramname">T</td><td>The type that describes the message body</td></tr>
  </table>
  </dd>
</dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">message</td><td>The message object that will be sent</td></tr>
    <tr><td class="paramname">deliveryAnnotations</td><td>Optional delivery annotation to include with the message</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A Tracker for the sent message</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html#a8fa7841abb0b85fa31f4786f23ee5cb4">Apache.Qpid.Proton.Client.Implementation.ClientStreamSender</a>.</p>

</div>
</div>
<a id="a082f33e2ca2b5d7c359503c2d8cf7deb"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a082f33e2ca2b5d7c359503c2d8cf7deb">&#9670;&nbsp;</a></span>SendAsync&lt; T &gt;()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Task&lt;<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a>&gt; Apache.Qpid.Proton.Client.IStreamSender.SendAsync&lt; T &gt; </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt;&#160;</td>
          <td class="paramname"><em>message</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">IDictionary&lt; string, object &gt;&#160;</td>
          <td class="paramname"><em>deliveryAnnotations</em> = <code>null</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>If no streaming send has been initiated and not yet completed then this method will send the given message immediately if there is credit available or waits if the link has not yet been granted credit. If a send timeout has been configured then this method will fail the returned Task with a timed out error after that if the message cannot be sent. The returned Task will be completed once the message has been sent. </p>
<dl class="tparams"><dt>Template Parameters</dt><dd>
  <table class="tparams">
    <tr><td class="paramname">T</td><td>The type that describes the message body</td></tr>
  </table>
  </dd>
</dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">message</td><td>The message object that will be sent</td></tr>
    <tr><td class="paramname">deliveryAnnotations</td><td>Optional delivery annotation to include with the message</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A Task that is completed with a Tracker once the send completes</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html#a3a00cc78d0f778acc5f7b863472cf1f7">Apache.Qpid.Proton.Client.Implementation.ClientStreamSender</a>.</p>

</div>
</div>
<a id="aad1fac7b9a02e987e981f9cc0cd8d4df"></a>
<h2 class="memtitle"><span class="permalink"><a href="#aad1fac7b9a02e987e981f9cc0cd8d4df">&#9670;&nbsp;</a></span>TrySend&lt; T &gt;()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a> Apache.Qpid.Proton.Client.IStreamSender.TrySend&lt; T &gt; </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt;&#160;</td>
          <td class="paramname"><em>message</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">IDictionary&lt; string, object &gt;&#160;</td>
          <td class="paramname"><em>deliveryAnnotations</em> = <code>null</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>If no streaming send has been initiated and not yet completed then this method will send the given message if credit is available or returns null if no credit has been granted to the link at the time of the send attempt. </p>
<dl class="tparams"><dt>Template Parameters</dt><dd>
  <table class="tparams">
    <tr><td class="paramname">T</td><td>The type that describes the message body</td></tr>
  </table>
  </dd>
</dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">message</td><td>The message object that will be sent</td></tr>
    <tr><td class="paramname">deliveryAnnotations</td><td>Optional delivery annotation to include with the message</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A Tracker for the sent message or null if no credit to send is available</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html#ab4325c4ee5fb5a9222542e6719b843a0">Apache.Qpid.Proton.Client.Implementation.ClientStreamSender</a>.</p>

</div>
</div>
<a id="acff11960d2b74020f33bcb5a909a6a2a"></a>
<h2 class="memtitle"><span class="permalink"><a href="#acff11960d2b74020f33bcb5a909a6a2a">&#9670;&nbsp;</a></span>TrySendAsync&lt; T &gt;()</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">Task&lt;<a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IStreamTracker.html">IStreamTracker</a>&gt; Apache.Qpid.Proton.Client.IStreamSender.TrySendAsync&lt; T &gt; </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="interfaceApache_1_1Qpid_1_1Proton_1_1Client_1_1IMessage.html">IMessage</a>&lt; T &gt;&#160;</td>
          <td class="paramname"><em>message</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">IDictionary&lt; string, object &gt;&#160;</td>
          <td class="paramname"><em>deliveryAnnotations</em> = <code>null</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>If no streaming send has been initiated and not yet completed then this method will send the given message if credit is available or completes the returned Task with null if no credit has been granted to the link at the time of the send attempt. </p>
<dl class="tparams"><dt>Template Parameters</dt><dd>
  <table class="tparams">
    <tr><td class="paramname">T</td><td>The type that describes the message body</td></tr>
  </table>
  </dd>
</dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">message</td><td>The message object that will be sent</td></tr>
    <tr><td class="paramname">deliveryAnnotations</td><td>Optional delivery annotation to include with the message</td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A Task that provides a tracker if the send completes or null if no credit</dd></dl>

<p>Implemented in <a class="el" href="classApache_1_1Qpid_1_1Proton_1_1Client_1_1Implementation_1_1ClientStreamSender.html#a4f4f7d57d50dabbc4fdaadacaea8ac50">Apache.Qpid.Proton.Client.Implementation.ClientStreamSender</a>.</p>

</div>
</div>
<hr/>The documentation for this interface was generated from the following file:<ul>
<li>src/Proton.Client/Client/IStreamSender.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>
