C1.LiveLinq.LiveViewExtensions.LiveMin
LiveMin Method
LiveMin(View<int>)
Computes the minimum value of a view of int values.
Declaration
public static AggregationView<int, int> LiveMin(this View<int> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<int> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<int, int> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<int?>)
Computes the minimum value of a view of nullable int values.
Declaration
public static AggregationView<int?, int?> LiveMin(this View<int?> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<int?> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<int?, int?> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, int>>)
Computes the minimum value of a view of int values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, int> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, int>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, int>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, int> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, int?>>)
Computes the minimum value of a view of nullable int values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, int?> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, int?>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, int?>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, int?> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<decimal>)
Computes the minimum value of a view of decimal values.
Declaration
public static AggregationView<decimal, decimal> LiveMin(this View<decimal> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<decimal> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<decimal, decimal> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<decimal?>)
Computes the minimum value of a view of nullable decimal values.
Declaration
public static AggregationView<decimal?, decimal?> LiveMin(this View<decimal?> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<decimal?> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<decimal?, decimal?> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, decimal>>)
Computes the minimum value of a view of decimal values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, decimal> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, decimal>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, decimal>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, decimal> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, decimal?>>)
Computes the minimum value of a view of nullable decimal values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, decimal?> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, decimal?>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, decimal?>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, decimal?> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<long>)
Computes the minimum value of a view of long values.
Declaration
public static AggregationView<long, long> LiveMin(this View<long> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<long> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<long, long> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<long?>)
Computes the minimum value of a view of nullable long values.
Declaration
public static AggregationView<long?, long?> LiveMin(this View<long?> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<long?> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<long?, long?> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, long>>)
Computes the minimum value of a view of long values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, long> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, long>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, long>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, long> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, long?>>)
Computes the minimum value of a view of nullable long values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, long?> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, long?>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, long?>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, long?> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<double>)
Computes the minimum value of a view of double values.
Declaration
public static AggregationView<double, double> LiveMin(this View<double> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<double> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<double, double> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<double?>)
Computes the minimum value of a view of nullable double values.
Declaration
public static AggregationView<double?, double?> LiveMin(this View<double?> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<double?> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<double?, double?> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, double>>)
Computes the minimum value of a view of double values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, double> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, double>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, double>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, double> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, double?>>)
Computes the minimum value of a view of nullable double values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, double?> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, double?>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, double?>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, double?> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<float>)
Computes the minimum value of a view of float values.
Declaration
public static AggregationView<float, float> LiveMin(this View<float> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<float> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<float, float> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin(View<float?>)
Computes the minimum value of a view of nullable float values.
Declaration
public static AggregationView<float?, float?> LiveMin(this View<float?> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<float?> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<float?, float?> | A view representing the minimum of the values. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, float>>)
Computes the minimum value of a view of float values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, float> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, float>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, float>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, float> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty, an InvalidOperationException is thrown.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>, Expression<Func<TSource, float?>>)
Computes the minimum value of a view of nullable float values that are obtained by invoking a transform function on each element of the source view.
Declaration
public static AggregationView<TSource, float?> LiveMin<TSource>(this View<TSource> source, Expression<Func<TSource, float?>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, float?>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, float?> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If the source is empty or contains only nulls, the minimum value is null.
It is possible to use standard LINQ query operator Min instead of LiveMin. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMin will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource, TResult>(View<TSource>, Expression<Func<TSource, TResult>>)
Invokes a transform function on each element of a view of elements of a generic type and computes the minimum resulting value.
Declaration
public static AggregationView<TSource, TResult> LiveMin<TSource, TResult>(this View<TSource> source, Expression<Func<TSource, TResult>> selector)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
| Expression<Func<TSource, TResult>> | selector | A transform function to apply to each element. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, TResult> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
| TResult | The type of the value returned by selector. |
Remarks
If type TResult implements IComparable<T>, this method uses that implementation to compare values. Otherwise, if type TResult implements IComparable, that implementation is used to compare values.
It is possible to use standard LINQ query operator Min instead of LiveMax. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMax will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.
LiveMin<TSource>(View<TSource>)
Computes the minimum value of a view of elements of a generic type.
Declaration
public static AggregationView<TSource, TSource> LiveMin<TSource>(this View<TSource> source)Parameters
| Type | Name | Description |
|---|---|---|
| View<TSource> | source | A view containing the values to determine the minimum value of. |
Returns
| Type | Description |
|---|---|
| AggregationView<TSource, TSource> | A view representing the minimum of the values. |
Type Parameters
| Name | Description |
|---|---|
| TSource | The type of the elements of source. |
Remarks
If type TSource implements IComparable<T>, this method uses that implementation to compare values. Otherwise, if type TSource implements IComparable, that implementation is used to compare values.
It is possible to use standard LINQ query operator Min instead of LiveMax. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Min will every time loop through the entire source collection and aggregate it from scratch, whereas LiveMax will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.