# C1.LiveLinq.LiveViewExtensions.LiveMax

## Content

<div class="doc-site-dotnet-api-container">



<h1 id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*">LiveMax Method
</h1>
<div class="markdown level0 summary"></div>
<div class="markdown level0 conceptual"></div>



<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Int32__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Int32})">LiveMax(View&lt;int&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;int, int&gt; LiveMax(this View&lt;int&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Integer)) As AggregationView(Of Integer, Integer)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Int32___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Int32___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Nullable{System.Int32}})">LiveMax(View&lt;int?&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;int?, int?&gt; LiveMax(this View&lt;int?&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Integer?)) As AggregationView(Of Integer?, Integer?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>?&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>?, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Int32____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Int32___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Int32}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, int&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, int&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, int&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Integer))) As AggregationView(Of TSource, Integer)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Int32____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Int32____" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Nullable{System.Int32}}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, int?&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, int?&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, int?&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Integer?))) As AggregationView(Of TSource, Integer?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>?&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int32">int</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Int32_____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Decimal__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Decimal})">LiveMax(View&lt;decimal&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;decimal, decimal&gt; LiveMax(this View&lt;decimal&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Decimal)) As AggregationView(Of Decimal, Decimal)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Decimal___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Decimal___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Nullable{System.Decimal}})">LiveMax(View&lt;decimal?&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;decimal?, decimal?&gt; LiveMax(this View&lt;decimal?&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Decimal?)) As AggregationView(Of Decimal?, Decimal?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>?&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>?, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Decimal____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Decimal___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Decimal}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, decimal&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, decimal&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, decimal&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Decimal))) As AggregationView(Of TSource, Decimal)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Decimal____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Decimal____" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Nullable{System.Decimal}}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, decimal?&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, decimal?&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, decimal?&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Decimal?))) As AggregationView(Of TSource, Decimal?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>?&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.decimal">decimal</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Decimal_____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Int64__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Int64})">LiveMax(View&lt;long&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;long, long&gt; LiveMax(this View&lt;long&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Long)) As AggregationView(Of Long, Long)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Int64___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Int64___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Nullable{System.Int64}})">LiveMax(View&lt;long?&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;long?, long?&gt; LiveMax(this View&lt;long?&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Long?)) As AggregationView(Of Long?, Long?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>?&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>?, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Int64____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Int64___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Int64}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, long&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, long&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, long&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Long))) As AggregationView(Of TSource, Long)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Int64____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Int64____" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Nullable{System.Int64}}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, long?&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, long?&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, long?&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Long?))) As AggregationView(Of TSource, Long?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>?&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.int64">long</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Int64_____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Double__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Double})">LiveMax(View&lt;double&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;double, double&gt; LiveMax(this View&lt;double&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Double)) As AggregationView(Of Double, Double)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Double___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Double___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Nullable{System.Double}})">LiveMax(View&lt;double?&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;double?, double?&gt; LiveMax(this View&lt;double?&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Double?)) As AggregationView(Of Double?, Double?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>?&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>?, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Double____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Double___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Double}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, double&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, double&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, double&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Double))) As AggregationView(Of TSource, Double)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Double____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Double____" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Nullable{System.Double}}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, double?&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, double?&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, double?&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Double?))) As AggregationView(Of TSource, Double?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>?&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.double">double</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Double_____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Single__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Single})">LiveMax(View&lt;float&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;float, float&gt; LiveMax(this View&lt;float&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Single)) As AggregationView(Of Single, Single)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Single___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Single___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax(C1.LiveLinq.LiveViews.View{System.Nullable{System.Single}})">LiveMax(View&lt;float?&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a> values.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;float?, float?&gt; LiveMax(this View&lt;float?&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(source As View(Of Single?)) As AggregationView(Of Single?, Single?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>?&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>?, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax_C1_LiveLinq_LiveViews_View_System_Nullable_System_Single____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Single___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Single}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, float&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, float&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, float&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Single))) As AggregationView(Of TSource, Single)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Single____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty, an <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.invalidoperationexception">InvalidOperationException</a> is thrown.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Single____" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Nullable{System.Single}}})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, float?&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of nullable <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a> values that are obtained
by invoking a transform function on each element of the source view.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, float?&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, float?&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, Single?))) As AggregationView(Of TSource, Single?)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>?&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.single">float</a>?&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0_System_Nullable_System_Single_____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If the <i>source</i> is empty or contains only nulls, the maximum value is null.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__2_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0___1___" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``2(C1.LiveLinq.LiveViews.View{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">LiveMax&lt;TSource, TResult&gt;(View&lt;TSource&gt;, Expression&lt;Func&lt;TSource, TResult&gt;&gt;)</h4>
<div class="markdown level1 summary"><p>Invokes a transform function on each element of a view of elements of a generic type and computes the maximum resulting value.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, TResult&gt; LiveMax&lt;TSource, TResult&gt;(this View&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, TResult&gt;&gt; selector)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource, TResult)(source As View(Of TSource), selector As Expression(Of Func(Of TSource, TResult))) As AggregationView(Of TSource, TResult)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
    <tr>
      <td><a class="xref" href="https://learn.microsoft.com/dotnet/api/system.linq.expressions.expression-1">Expression</a>&lt;<a class="xref" href="https://learn.microsoft.com/dotnet/api/system.func-2">Func</a>&lt;TSource, TResult&gt;&gt;</td>
      <td><span class="parametername">selector</span></td>
      <td><p>A transform function to apply to each element.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, TResult&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
    <tr>
      <td><span class="parametername">TResult</span></td>
      <td><p>The type of the value returned by <i>selector</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__2_C1_LiveLinq_LiveViews_View___0__System_Linq_Expressions_Expression_System_Func___0___1____remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If type <i>TResult</i> implements <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.icomparable-1">IComparable&lt;T&gt;</a>, this method uses that implementation to compare values.
Otherwise, if type <i>TResult</i> implements <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.icomparable">IComparable</a>, that implementation is used to compare values.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>


<a id="C1_LiveLinq_LiveViewExtensions_LiveMax_" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax*"></a>
<h4 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0__" data-uid="C1.LiveLinq.LiveViewExtensions.LiveMax``1(C1.LiveLinq.LiveViews.View{``0})">LiveMax&lt;TSource&gt;(View&lt;TSource&gt;)</h4>
<div class="markdown level1 summary"><p>Computes the maximum value of a view of elements of a generic type.</p>
</div>
<div class="markdown level1 conceptual"></div>
<h5 class="declaration">Declaration</h5>
<div class="codewrapper">
  <pre><code class="lang-csharp hljs">public static AggregationView&lt;TSource, TSource&gt; LiveMax&lt;TSource&gt;(this View&lt;TSource&gt; source)</code></pre>
</div>
<div class="codewrapper">
  <pre><code class="lang-vbnet hljs">Public Shared Function LiveMax(Of TSource)(source As View(Of TSource)) As AggregationView(Of TSource, TSource)</code></pre>
</div>
<h5 class="parameters">Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.View-1.html">View</a>&lt;TSource&gt;</td>
      <td><span class="parametername">source</span></td>
      <td><p>A view containing the values to determine the maximum value of.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="returns">Returns</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Type</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a class="xref" href="C1.LiveLinq.LiveViews.AggregationView-2.html">AggregationView</a>&lt;TSource, TSource&gt;</td>
      <td><p>A view representing the maximum of the values.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 class="typeParameters">Type Parameters</h5>
<table class="table table-bordered table-condensed">
  <thead>
    <tr>
      <th>Name</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><span class="parametername">TSource</span></td>
      <td><p>The type of the elements of <i>source</i>.</p>
</td>
    </tr>
  </tbody>
</table>
<h5 id="C1_LiveLinq_LiveViewExtensions_LiveMax__1_C1_LiveLinq_LiveViews_View___0___remarks">Remarks</h5>
<div class="markdown level1 remarks"><p>If type <i>TSource</i> implements <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.icomparable-1">IComparable&lt;T&gt;</a>, this method uses that implementation to compare values.
Otherwise, if type <i>TSource</i> implements <a class="xref" href="https://learn.microsoft.com/dotnet/api/system.icomparable">IComparable</a>, that implementation is used to compare values.</p>
<p>It is possible to use standard LINQ query operator <b>Max</b> instead of <b>LiveMax</b>.
Both are "live" in the sense that they are recomputed automatically when any change occurs in the source.
The difference is that <b>Max</b> will every time loop through the entire source collection and aggregate it from scratch,
whereas <b>LiveMax</b> will use a more performant algorithm, will maintain its value incrementally,
processing only those source items that actually changed.</p>
</div>
</div>