LiveLinq Overview

LiveLinq is a class library that augments the functionality of LINQ in two related directions:

· It makes LINQ faster

LiveLinq uses indexing and other optimizations to speed up LINQ queries in memory. Speed gains can be hundreds and even thousands of times on queries with high selectivity conditions. Typical/average gains are lower but still significant, a 10-50 times speedup can be considered typical.

· It adds support for live views to LINQ

A live view is a LINQ query result that is kept constantly up-to-date without re-populating it every time its base data changes. This makes LiveLinq extremely useful in common data-binding scenarios where objects are edited and may be filtered in or out of views, have their associated subtotals updated, and so on. In old jargon, one could say that LINQ queries correspond to snapshots, while LiveLinq view correspond to dynasets. Since live views automatically react to changes, they greatly widen the sphere of declarative programming, not only in data binding and GUI but in many other programming scenarios as well.

The scope of LiveLinq

LiveLinq implements three LINQ varieties:

· LINQ to Objects

· LINQ to XML

· LINQ to DataSet

In other words, its scope is LINQ in memory. The current LiveLinq version does not offer an alternative to LINQ to databases. However, this does not prevent you from using LiveLinq with data retrieved to memory from a database. For example, you can retrieve data from a database to a dataset in memory using ADO.NET and then use LiveLinq to DataSet, or you can retrieve objects from a database using LINQ to SQL or Entity Framework, then operate on that data using LiveLinq and then send changes to the database using again Entity Framework or another framework of your choice.

LiveLinq and LINQ

LiveLinq has the same syntax as the standard LINQ. The only change necessary is to wrap your data source by applying to it an extension method AsIndexed() (for indexing) or AsLive() (for live views).

How the two parts of LiveLinq are related to each other

The two areas of LiveLinq functionality, indexing and live views can interoperate but are independent. It is not necessary to define indexes if you need to create a live view. A view is populated initially by executing a query, so, if the query can be optimized using indexing, the view will be populated faster. But after its initial population, changes to the view are made using special optimization techniques (known as Incremental View Maintenance) that don't require the user to explicitly define indexes.

Faster LINQ with Indexing

LiveLinq contains an indexing framework that it uses for optimizing query performance. For example, by defining an index by ProductID, we can dramatically speed up queries like

from p in products where p.ProductID == 100

because it will use the index to access the requested product directly instead of going through the entire large collection in search of a single product.

Same indexes can also be used programmatically, in code, even without LINQ, for various kinds of searches, including range search and others.

Declarative programming with Live Views

Live (real) data binding

LiveLinq adds the concept of view to LINQ. A view is a query with a resultset that remains live, dynamic after it is initially populated by executing the query. A standard LINQ query is a snapshot, in the sense that its result list does not change when you change the underlying (base) data. So it can't be used for full-featured data binding. A live view is automatically kept in sync with base data, so it enables full data binding to LINQ queries.

Moreover, many views are updatable themselves, you can modify properties in their objects and add and delete objects directly in the view, see Updatable Views. So, a view can be modifiable in both directions: changes in base data propagate to the view and changes in the view propagate to base data (the latter pursuant to usual conditions of updatability).

This is full-featured two-way data binding.

Reactive = "View-Oriented" = Declarative Programming

Data binding, which is mostly used in GUI, is a very important part of live views functionality, but not the only one. More generally, live views enable a declarative style of programming which we tentatively call "view-oriented programming". Non-GUI, batch processing code can also be made declarative using live views.

Enabling technology: Incrementality

When a change occurs in base data, live views update themselves in a smart, fast way, not simply repopulate themselves from scratch. The changes are made locally, incrementally, calculating the delta in the view from the delta in the base data. In most cases, it allows to propagate the change from base data to the view very fast. This is a key component of LiveLinq: its enabling technology, based on an area of Computer Science known as Incremental View Maintenance. But the user does not need to do anything to enable this optimization, as it is done entirely beneath the hood, transparent to the user.


Getting Started

The following sections will help you get started with LiveLinq.

More:

What is LINQ?

What is LiveLinq?

How does LiveLinq work?

Getting Started with LiveLinq


What is LINQ?

LINQ, or Language Integrated Query, is a set of features in .NET 3.5 used for writing structured type-safe queries over local object collections and remote data sources.

LINQ enables you to query any collection implementing the IEnumerable interface, including arrays, lists, XML documents, as well as remote data sources such as tables in SQL Server.

LINQ offers the following important benefits:

· Compile-time type-checking

· Language integration (including IntelliSense support)

· Uniformity across different data sources

· Flexible, powerful, and expressive queries

In order to use LiveLinq effectively, you must be reasonably proficient in LINQ. A deep coverage of LINQ is beyond the scope of this document, but there are several excellent resources available on the subject. We recommend the following:

· “C# 3.0 in a nutshell”, by Joseph and Ben Albahari. O’Reilly, 2007.

· “LINQ in Action”, by Fabrice Marguerie, Steve Eichert and Jim Wooley. Manning, 2008.

· “Programming Microsoft LINQ Developer Reference”, by Paolo Pialorsi and Marco Russo. Microsoft Press, 2008.


What is LiveLinq?

LiveLinq is a set of extensions to LINQ that add two important capabilities to standard LINQ queries:

1. LiveLinq optimizes LINQ queries
LiveLinq uses indexing and other optimizations to speed up LINQ queries. Speed gains of 10 to 50 times are typical for non-trivial queries. The overall performance gains can be dramatic for data-centric applications that rely heavily on LINQ.

2. LiveLinq turns LINQ query results into Live Views
Live views are query results that are kept up-to-date with respect to the base data. Live views are essential to data binding scenarios where objects may be added, removed, or changed while bound to controls in the UI. Using old jargon, one could say that plain LINQ queries correspond to snapshots, while LiveLinq views correspond to dynasets.


How does LiveLinq work?

LiveLinq implements “Incremental View Maintenance” techniques. Unlike standard LINQ, LiveLinq does not discard all query information after executing. Instead, it keeps the data it processes in indexed lists which are incrementally updated and synchronized as the underlying data changes.

The overhead involved is relatively small, since the data is already in memory to begin with (LiveLinq only operates with in-memory data). The benefits are huge: LiveLinq not only accelerates typical queries by orders of magnitude, but also enables the use of LINQ in data binding scenarios that would not be possible with standard LINQ.


Getting Started with LiveLinq

We will show several samples that illustrate LiveLinq. All the samples presented here use the Northwind database. You can use the Access version (NWIND.MDB) or the SQL Server version (NORTHWND.MDF). If you don’t have Northwind and would like to try the samples, you can download the SQL Server version of the database from this URL:

http://www.microsoft.com/downloads/details.aspx?
FamilyID=06616212-0356-46A0-8DA2-EEBC53A68034

The LiveLinq distribution package includes more samples and demos that show details not covered in the "Getting Started" part of the documentation.

More:

Optimizing LINQ Queries with LiveLinq

Basic LiveLinq Binding

Hierarchical LiveLinq Binding

LiveLinq and Declarative Programming


Optimizing LINQ Queries with LiveLinq

In this section, we will show a sample that illustrates how LiveLinq can optimize queries that use the where operator to filter data.

To start, follow these steps:

1. Create a new WinForms project

2. Add a reference to the C1.LiveLinq.dll assembly

3. Use the Data | Add New DataSource menu and add a reference to the NORTHWND.MDF database. Accept all the default options offered by the wizard, and pick all the tables in the database.

At this point, your project should look like this:

Next, double-click the form and add the following code:

// declare northwind DataSet

NORTHWNDDataSet _ds = new NORTHWNDDataSet();

private void Form1_Load(object sender, EventArgs e)

{

// load data into DataSet

new NORTHWNDDataSetTableAdapters.CustomersTableAdapter()

.Fill(_ds.Customers);

new NORTHWNDDataSetTableAdapters.OrdersTableAdapter()

.Fill(_ds.Orders);

}

This code declares an ADO.NET DataSet and loads some data into it.

Now that we have some data, let’s do something with it.

Add a button to the form, double-click it, and then enter the following code:

private void button1_Click(object sender, EventArgs e)

{

// get reference to source data

var customers = _ds.Customers;

var orders = _ds.Orders;

// find all orders for the first customer

var q =

from o in orders

where o.CustomerID == customers[0].CustomerID

select o;

// benchmark the query (execute 1000 times)

var start = DateTime.Now;

int count = 0;

for (int i = 0; i < 1000; i++)

{

foreach (var d in q)

count++;

}

Console.WriteLine("LINQ query done in {0} ms",

DateTime.Now.Subtract(start).TotalMilliseconds);

}

The code creates a simple LINQ query that enumerates all orders for the first customer in the database, then executes the query 1000 times and reports how long the process took.

If you run the project now and click the button, the Visual Studio output window should show something like this:

LINK query done in 262 ms

Now let us optimize this query with LiveLinq.

Start by adding the following using statements to the top of the code:

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

Next, add a second button to the form, double-click it and enter the following code:

private void button2_Click(object sender, EventArgs e)

{

// get reference to source data

var customers = _ds.Customers;

var orders = _ds.Orders;

// find all orders for the first customer

var q =

from o in orders.AsIndexed()

where o.CustomerID.Indexed() == customers[0].CustomerID

select o;

// benchmark the query (execute 1000 times)

var start = DateTime.Now;

int count = 0;

for (int i = 0; i < 1000; i++)

{

foreach (var d in q)

count++;

}

Console.WriteLine("LiveLinq query done in {0} ms",

DateTime.Now.Subtract(start).TotalMilliseconds);

}

The code is almost identical to the plain LINQ version we used before. The only differences are:

· We use the AsIndexed method to convert the orders table into a LiveLinq indexed data source,

· We use the Indexed method to indicate to LiveLinq that it should index the data source by customer id,

AND

· The output message changed to show we are using LiveLinq now.

If you run the project again and click both buttons a few times, you should get something like this:

LINQ query done in 265 ms

LINQ query done in 305 ms

LINQ query done in 278 ms

LiveLinq query done in 124 ms

LiveLinq query done in 7 ms

LiveLinq query done in 2 ms

Notice how the plain LINQ query takes roughly the same amount of time whenever it executes. The LiveLinq query, on the other hand, is about twice as fast the first time it executes, and about one hundred times faster for all subsequent runs. This level of performance gain is typical for this type of query.

This happens because LiveLinq has to build the index when the query is executed for the first time. From then on, the same index is reused and performance improves dramatically. Note that the index is automatically maintained, so it is always up-to-date even when the underlying data changes.

In this example, the index was created when the Indexed method executed for the first time. You can also manage indexes using code if you need the extra control. For example, the code below declares an indexed collection and explicitly adds an index on the CustomerID field:

var ordersIndexed = _ds.Orders.AsIndexed();

ordersIndexed.Indexes.Add(o => o.CustomerID);

Note that the indexes are associated with the source data, and are kept even if the collection goes out of scope. If you executed the code above once, the index would remain active even after the ordersIndexed collection went out of scope.

Note also that the AsIndexed method is supported only for collections that provide change notifications (LiveLinq has to monitor changes in order to maintain its indexes). This requirement is satisfied for all common collections used in WinForms and WPF data binding. In particular, AsIndexed can be used with DataTable, DataView, BindingList<T>, ObservableCollection<T>, and LINQ to XML collections.

The LiveLinq installation includes a sample called LiveLinqQueries that contains many other examples with benchmarks, and includes queries against plain CLR objects, ADO.NET, and XML data.

Summarizing, LiveLinq can significantly optimize queries that search for any type of data that can be sorted. For example, searching for a specific customer or product, or listing products within a certain price range. These are typical queries that can be easily optimized to perform about a hundred times faster that they would using plain LINQ.


Basic LiveLinq Binding

Besides accelerating typical queries, LiveLinq also enables the use of LINQ in data binding scenarios.

To illustrate this, let us start with a simple example.

1. Create a new WinForms project

2. Add a reference to the C1.LiveLinq.dll assembly

3. Add a button and a DataGridView to the main form

4. Double-click the button and add this code to the form:

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

using C1.LiveLinq.LiveViews;

using C1.LiveLinq.Collections;

private void button1_Click(object sender, EventArgs e)

{

// create data source

var contacts = new IndexedCollection<Contact>();

// bind list to grid (before adding elements)

this.dataGridView1.DataSource =

from c in contacts.AsLive()

where c.Name.Contains("g")

select c;

// add elements to collection (after binding)

var names = "Paul,Ringo,John,George,Robert,Jimmy,John Paul,Bonzo";

foreach (string s in names.Split(','))

{

contacts.Add(new Contact() { Name = s });

}

}

public class Contact : IndexableObject

{

private string _name;

public string Name

{

get { return _name; }

set

{

OnPropertyChanging("Name");

_name = value;

OnPropertyChanged("Name");

}

}

If you run the project and click the button, you should see two names on the grid: “Ringo” and “George”:

This may not seem surprising, since the data source is a query that returns all names that contain the letter “g”.

The interesting part is that all the contacts were added to the list after the query was assigned to the grid’s DataSource property. This shows that the LiveLinq query actually returned a live list, one that (a) notified the grid when elements were added to it, and (b) honored the where operator by showing only the names that contain “g”.

The differences between this LiveLinq query and a regular one are:

1. The object collection is of type IndexedCollection<T>. This is a class provided by LiveLinq that supports the required change notifications.

2. The Contact class is derived from a LiveLinq class IndexedObject so it can provide change notifications when its properties are set.

3. The query itself contains an AsLive call that tells LiveLinq we want the result to remain active and issue change notifications that will be handled by bound controls.

You can test that the filter condition remains active by editing the grid and changing “Ringo” into “Ricky”. The row will be filtered out of the view as soon as you finish editing.

You can also check the effect of the AsLive call by commenting it out and running the sample again. This time, the grid will not receive any notifications as items are added to the list, and will remain empty.


Hierarchical LiveLinq Binding

The previous example showed how LiveLinq provides basic data binding against plain CLR objects.

In this section, we will show how LiveLinq supports more advanced scenarios including master-detail data binding and currency management (data cursors). We will use an ADO.NET data source, but the principles are the same for all other in-memory data sources, including plain CLR objects and XML data.

We will start with a simple application using traditional data binding. We will then show how you can easily convert that application to take advantage of LiveLinq. Finally, we will create WinForms and WPF versions of the application using LiveLinq from the start.

More:

Traditional WinForms Implementation

Switching to LiveLinq

LiveLinq implementation in WinForms

LiveLinq implementation in WPF


Traditional WinForms Implementation

Our sample application will consist of the following elements:

· A ComboBox listing the NorthWind product categories.

· A DataGridView showing all products for the currently selected category.

· Some TextBox controls bound to properties of the currently selected product.

This is what the final application will look like:

The basic implementation is simple, since Visual Studio handles most of the data binding related tasks automatically. In fact, the entire application can be written without a single line of code.

Here are the steps:

1. Create a new WinForms application

2. Use the Data | Add New DataSource menu and add a reference to the NORTHWND.MDF database. Accept all the default options offered by the wizard, and pick all the tables in the database.

3. Add the controls to the form as shown on the image above: one ComboBox, one DataGridView, four TextBox controls, and a few Label controls.

At this point, the application has access to the data and it has controls to show and edit the data. To connect the controls to the data, follow these steps:

1. Add a new BindingSource component to the form

2. Select the new BindingSource component, select its DataSource property in the property window, and use the drop-down editor to select the NORTHWINDDataSet data set.

3. Still with the BindingSource component selected, use the drop-down editor set the DataMember property to “Categories”.

The final step is to select each data bound control and bind it to the BindingSource component:

For the ComboBox, set the following properties:

DataSource bindingSource1
DisplayMember CategoryName
ValueMember CategoryID

For the DataGridView, use the drop-down editor in the property grid to set the DataSource property to FK_Products_Categories, the item that appears under bindingSource1 and represents the products under the currently selected category. The image below shows what the drop-down editor looks like just before the selection is made:

Finally, select each of the TextBox controls and use the drop-down editor in the property window to bind the Text property to the corresponding element in the currently selected product. For example:

Repeat this step to bind the other TextBox controls to the UnitPrice, QuantityPerUnit, and UnitsInStock fields.

The application is now ready. Run it and notice the following:

· When you select a category from the ComboBox, the corresponding products are displayed on the grid below, and the product details appear in the TextBox controls.

· When you select a product on the grid, the product details are automatically updated.

· The values shown on the grid and in the text boxes are synchronized. If you change the values in one place, they also change in the other.

· If you change the value of a product’s CategoryID in the grid, the product no longer belongs to the currently selected category and is automatically removed from the grid.

This is the traditional way of doing data binding in WinForms. Visual Studio provides rich design-time support and tools that make it easy to get applications started. Of course, real applications typically require you to add some code to implement specific logic.


Switching to LiveLinq

The application we just described relies on a bindingSource object that exposes an ADO.NET DataTable as a data source. Migrating this application to LiveLinq is very easy. All you need to do is have the bindingSource object expose a LiveLinq view instead of a regular DataTable.

Here are the steps required:

1. Add a reference to the C1.LiveLinq.dll assembly to the project.

2. Add a few using statements to make the code more readable:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

using C1.LiveLinq.LiveViews;

1. Create a LiveLinq query and assign it to the DataSource property of the bindingSource object, replacing the original reference to a DataTable object:

private void Form1_Load(object sender, EventArgs e)

{

// generated automatically

this.productsTableAdapter.Fill(this.nORTHWNDDataSet.Products);

this.categoriesTableAdapter.Fill(this.nORTHWNDDataSet.Categories);

// Create a live view for Categories.

// Each category contains a list with the products of that category.

var categoryView =

from c in nORTHWNDDataSet.Categories.AsLive()

join p in nORTHWNDDataSet.Products.AsLive()

on c.CategoryID equals p.CategoryID into g

select new

{

c.CategoryID,

c.CategoryName,

FK_Products_Categories = g

};

// replace DataSource on the form to use our LiveLinq Query

this.bindingSource1.DataSource = categoryView;

}

The code starts by creating the LiveLinq query that will serve as a data source for all controls on the form.

The query is 100% standard LINQ, except for the AsLive statements which turn the standard LINQ query into a live view suitable for binding. Without them, the code would not even compile.

The query uses a join to obtain all products for each category and store them in a group, and then selects the category ID, category name, and the group of products associated with the category.

The group of products is named FK_Products_Categories. We did not name it something simple and intuitive like “Products” because the binding code created behind the scenes by Visual Studio relies on this specific name.

If you look at the Form1.Designer.cs file, you will notice that Visual Studio created a bindingSource object named fKProductsCategoriesBindingSource which is initialized as follows:

//

// fKProductsCategoriesBindingSource

//

this.fKProductsCategoriesBindingSource.DataMember = "FK_Products_Categories";

this.fKProductsCategoriesBindingSource.DataSource = this.bindingSource1;

This code assumes that the original binding source contains a property named "FK_Products_Categories" that exposes the list of products for the current category. To ensure that the bindings still work, our query needs to use the same name.

If you run the project now, you will see that it works exactly as it did before. But now it is fully driven by a LINQ query, which means we have gained a lot of flexibility. It would be easy to rewrite the LINQ statement and display additional information such as supplier names, total sales, etc.


LiveLinq implementation in WinForms

The previous section described how to migrate a traditional data-bound application to use LiveLinq. The resulting application used BindingSource objects and code that was generated by Visual Studio at design time.

If we wanted to create a new LiveLinq application from scratch, we could make it even simpler.

Here are the steps:

1. Create a new WinForms application

2. Use the Data | Add New DataSource menu and add a reference to the NORTHWND.MDF database. Accept all the default options offered by the wizard, and pick all the tables in the database.

3. Add the controls to the form as before: one ComboBox, one DataGridView, four TextBox controls, and a few Label controls.

4. Add a reference to the C1.LiveLinq.dll assembly to the project.

5. Double-click the form add the following code:

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

using C1.LiveLinq.LiveViews;

private void Form1_Load(object sender, EventArgs e)

{

// get the data

var ds = GetData();

// create a live view with Categories and Products:

var liveView =

from c in ds.Categories.AsLive()

join p in ds.Products.AsLive()

on c.CategoryID equals p.CategoryID into g

select new

{

c.CategoryID,

c.CategoryName,

Products = g

};

// bind view to controls

DataBind(liveView);

}

The code is straightforward. It calls a GetData method to load the data into a DataSet, creates a LiveLinq view using a LINQ statement similar to the one we used earlier, and then calls DataBind to bind the controls on the form to the view.

Here is the implementation of the GetData method:

NORTHWNDDataSet GetData()

{

NORTHWNDDataSet ds = new NORTHWNDDataSet();

new NORTHWNDDataSetTableAdapters.ProductsTableAdapter()

.Fill(ds.Products);

new NORTHWNDDataSetTableAdapters.CategoriesTableAdapter()

.Fill(ds.Categories);

return ds;

}

GetData creates a NORTHWNDDataSet, fills the “Products” and “Categories” tables using the adapters created by Visual Studio at design time, and returns the data set.

Here is the implementation of the DataBind method:

void DataBind(object dataSource)

{

// bind ComboBox

comboBox1.DataSource = dataSource;

comboBox1.DisplayMember = "CategoryName";

comboBox1.ValueMember = "CategoryID";

// bind DataGridView

dataGridView1.DataMember = "Products";

dataGridView1.DataSource = dataSource;

// bind TextBox controls

BindTextBox(textBox1, dataSource, "ProductName");

BindTextBox(textBox2, dataSource, "UnitPrice");

BindTextBox(textBox3, dataSource, "QuantityPerUnit");

BindTextBox(textBox4, dataSource, "UnitsInStock");

}

void BindTextBox(TextBox txt, object dataSource, string dataMember)

{

var b = new Binding("Text", dataSource, "Products." + dataMember);

txt.DataBindings.Add(b);

}

DataBind sets the data binding properties on each control to bind them to our LiveLinq view. This is exactly the same thing we did before using the property window editors, except this time we are doing it all in code and binding the controls directly to the LiveLinq view instead of going through a BindingSource component.

If you run the project now, you will see that it still works exactly as before.

Writing the data binding code usually takes a little longer than using the design time editors and letting Visual Studio write the code for you. On the other hand, the result is usually code that is simpler, easier to maintain, and easier to port to other platforms (as we will do in the next section).

Either way, you can use LiveLinq views as binding sources for the controls on the form.


LiveLinq implementation in WPF

In this section, we will create another version of the same application, this time using WPF.

Here are the steps:

1. Create a new WPF application

2. Use the Data | Add New DataSource menu and add a reference to the NORTHWND.MDF database. Accept all the default options offered by the wizard, and pick all the tables in the database.

3. Add a reference to the C1.LiveLinq.dll assembly to the project.

4. Add a reference to a grid control such as the C1.WPF.C1DataGrid, which you can download from www.componentone.com.

5. Add the controls to the main window: one ComboBox, one C1DataGrid, four TextBox controls, and five Label controls. Adjust the control layout so it looks like the previous version of our application, similar to the image below:

Now right-click the window, select View Code, and add the following code to the project:

using System;

using System.Linq;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

using C1.LiveLinq.LiveViews;

namespace LiveLinqWPF

{

/// <summary>

/// Interaction logic for Window1.xaml

/// </summary>

public partial class Window1 : Window

{

public Window1()

{

// designer-generated code

InitializeComponent();

// get data

var ds = GetData();

// create a live view with Categories and Products:

var liveView =

from c in ds.Categories.AsLive()

join p in ds.Products.AsLive()

on c.CategoryID equals p.CategoryID into g

select new

{

CategoryID = c.CategoryID,

CategoryName = c.CategoryName,

Products = g

};

// bind view to controls

DataBind(liveView);

}

}

}

The code is identical to the version we wrote earlier for the WinForms version of the application. It calls GetData to load the SQL data into a DataSet, then creates a LiveLinq view that exposes the data to the application, and finally calls the DataBind method to bind the controls to the LiveLinq view.

The GetData method is also identical to the one we used in the WinForms version of the application:

NORTHWNDDataSet GetData()

{

NORTHWNDDataSet ds = new NORTHWNDDataSet();

new NORTHWNDDataSetTableAdapters.ProductsTableAdapter()

.Fill(ds.Products);

new NORTHWNDDataSetTableAdapters.CategoriesTableAdapter()

.Fill(ds.Categories);

return ds;

}

The DataBind method is similar to the one we wrote earlier, but it is not identical. The WPF data binding mechanism is slightly different from the one in WinForms, and that is reflected here:

void DataBind(System.Collections.IEnumerable dataSource)

{

// show categories in ComboBox

comboBox1.ItemsSource = dataSource;

comboBox1.DisplayMemberPath = "CategoryName";

comboBox1.SelectedIndex = 0;

// show products in C1DataGrid

var b = new Binding("SelectedValue.Value.Products");

b.Source = comboBox1;

c1DataGrid1.SetBinding(C1.WPF.C1DataGrid.C1DataGrid.ItemsSourceProperty, b);

// show product details in TextBox controls

BindControl(textBox1, "ProductName");

BindControl(textBox2, "UnitPrice");

BindControl(textBox3, "QuantityPerUnit");

BindControl(textBox4, "UnitsInStock");

}

void BindControl(TextBox txt, string dataMember)

{

var b = new Binding("SelectedGridItem.Row.DataItem." + dataMember);

b.Source = c1DataGrid1;

txt.SetBinding(TextBox.TextProperty, b);

}

The WPF version of the DataBind method starts by assigning our live view to the ItemsSource property of the ComboBox control. It also sets the DisplayMemberPath property of the ComboBox to “CategoryName”, which is the field we want to show in the ComboBox.

Next, we use the SetBinding method to bind the grid’s ItemsSource property to the ComboBox selection. The string “SelectedValue.Value.Products” selects the “Products” field of the item that is currently selected in the ComboBox.

Finally, we use SetBinding to bind the Text property of each TextBox to the corresponding field on the grid selection. This time, we use strings like “SelectedGridItem.Row.DataItem.ProductName” which select specific properties of the product that is currently selected on the grid.

That concludes the WPF version of the application. If you run it now, you will see that it behaves exactly like the WinForms versions. Select categories from the top ComboBox, see the corresponding products on the grid below, and the product details in the TextBoxes at the bottom of the window.


LiveLinq and Declarative Programming

The live views provided by LiveLinq are not restricted to data binding scenarios.

Live views can be used to combine data from multiple tables, group and aggregate this data according to business rules, and make it available to the application at all times. The views are always synchronized with the data, so there’s no need to call methods to update the views when you need the data. This greatly simplifies application logic and improves efficiency.

To illustrate this point, imagine a NorthWind application that exposes the following services:

ProcessOrder: This service bills the customers, ships the products, and updates the information in the database. It is used by the sales force and by the company web store.

SalesInformation: This service returns summaries of sales per product and product category. It is used by management and marketing.

You could implement the application by having the ProcessOrder service write orders directly into the database and having the SalesInformation service run a stored procedure that would return the latest sales summaries. This would work, but the SalesInformation service would be relatively expensive since it would go to the database every time and would have to scan all the orders in the database.

Another approach would be to load the data into live views, where the sales summaries would be kept constantly up to date as orders are processed. Calls to the ProcessOrder method would automatically update the summaries provided by SalesInformation. Calls to SalesInformation would be processed in zero time, without touching the database at all.

To illustrate this, let us create another simple WinForms application using the NorthWind data once again. The application will have three grids. The first corresponds to the ProcessOrder service, allowing users to edit orders. The others correspond to the SalesInformation service, showing sales summaries that are always synchronized with the orders.

Here are the steps:

1. Create a new WinForms application

2. Use the Data | Add New DataSource menu and add a reference to the NORTHWND.MDF database. Accept all the default options offered by the wizard, and pick all the tables in the database.

3. Add a reference to the C1.LiveLinq.dll assembly to the project.

4. Add three DataGridView controls to the form, with labels above each one as shown in the image below.

Now, right-click the form and enter the following code:

using C1.LiveLinq;

using C1.LiveLinq.AdoNet;

using C1.LiveLinq.LiveViews;

public Form1()

{

InitializeComponent();

// get the data

NORTHWNDDataSet ds = GetData();

// create a live view to update order details

this.dataGridView1.DataSource = GetOrderDetails(ds);

// create live views that provide up-to-date order information

this.dataGridView2.DataSource = GetSalesByCategory(ds);

this.dataGridView3.DataSource = GetSalesByProduct(ds);

}

As before, the first step is loading the relevant data from the database:

NORTHWNDDataSet GetData()

{

var ds = new NORTHWNDDataSet();

new NORTHWNDDataSetTableAdapters.ProductsTableAdapter()

.Fill(ds.Products);

new NORTHWNDDataSetTableAdapters.Order_DetailsTableAdapter()

.Fill(ds.Order_Details);

new NORTHWNDDataSetTableAdapters.CategoriesTableAdapter()

.Fill(ds.Categories);

return ds;

}

Next, we use LiveLinq to implement the live view that will be exposed through the SalesInformation service. This is a standard LINQ query, only slightly more sophisticated than the ones we used in earlier samples, with a couple of AsLive clauses that turn the standard query into a live view:

object GetSalesByCategory(NORTHWNDDataSet ds)

{

var products = ds.Products;

var details = ds.Order_Details;

var categories = ds.Categories;

var salesByCategory =

from p in products.AsLive()

join c in categories.AsLive()

on p.CategoryID equals c.CategoryID

join d in details.AsLive()

on p.ProductID equals d.ProductID

let detail = new

{

CategoryName = c.CategoryName,

SaleAmount = d.UnitPrice * d.Quantity

* (decimal)(1f - d.Discount)

}

group detail

by detail.CategoryName into categorySales

let total = categorySales.Sum(x => x.SaleAmount)

orderby total descending

select new

{

CategoryName = categorySales.Key,

TotalSales = total

};

return salesByCategory;

}

The query starts by joining the three tables that contain the information on products, categories, and orders. It then creates a temporary detail variable that holds the product category and total amount for each order detail. Finally, the details are ordered by sales totals and grouped by category name.

The result is a live view that is automatically updated when the underlying data changes. You will see this a little later, when we run the app.

The next live view is similar, except it provides sales information by product instead of by category.

object GetSalesByProduct(NORTHWNDDataSet ds)

{

var products = ds.Products;

var details = ds.Order_Details;

var categories = ds.Categories;

var salesByProduct =

from p in products.AsLive()

join c in categories.AsLive()

on p.CategoryID equals c.CategoryID

join d in details.AsLive()

on p.ProductID equals d.ProductID

into sales

let productSales = new

{

ProductName = p.ProductName,

CategoryName = c.CategoryName,

TotalSales = sales.Sum(

d => d.UnitPrice * d.Quantity *

(decimal)(1f - d.Discount))

}

orderby productSales.TotalSales descending

select productSales;

return salesByProduct;

}

The last view shows the order details. We will bind this view to an editable grid so we can simulate orders being created or modified, and how the changes affect the previous views:

object GetOrderDetails(NORTHWNDDataSet ds)

{

var products = ds.Products;

var details = ds.Order_Details;

var categories = ds.Categories;

var orderDetails =

from d in details.AsLive().AsUpdatable()

join p in products.AsLive()

on d.ProductID equals p.ProductID

join c in categories.AsLive()

on p.CategoryID equals c.CategoryID

select new

{

c.CategoryName,

p.ProductName,

d.UnitPrice,

d.Quantity,

d.Discount

};

return orderDetails;

}

If you run the application now, you should see a window like this one:

The application shows the total sales by category and by product, sorted by amount. The best-selling category is “Beverages”, and the best-selling product is “Cote de Blaye”.

Now click the “ProductName” column header on the top grid and scroll down to find the entries for “Cote de Blaye”. Once you’ve found them, try making a few changes to the orders and see how the summary data is immediately updated. For example, if you change the quantities to zero for a few “Cote de Blaye” orders, you will see that “Beverages” quickly falls behind the “Diary Products” category:

This simple example illustrates the power of LINQ-based live views. They bridge the gap between data and logic and can make data-centric applications much simpler and more efficient.


How to query collections with LiveLinq

To use LiveLinq in Visual Studio, start by adding the LiveLinq assembly, C1.LiveLinq.dll, to your project's References. Then add the 'using' directives to the source file that will enable you to use LiveLinq in code:

using C1.LiveLinq;

using C1.LiveLinq.Indexing;

using C1.LiveLinq.Collections;

(Not all of them are always necessary, but let's put all of them there at once for simplicity)

In order to query a collection in LiveLinq, we need to wrap it in an interface IIndexedSource<T> that will tell LiveLinq to take over. Otherwise, standard LINQ will be used. This wrapping is done with a call to the AsIndexed extension method, for example:

from c in source.AsIndexed() where c.p == 1 select source

However, not every collection can be wrapped this way. For instance, if we try this with a List<T> source, we'll get a compilation error. To be usable in LiveLinq, a collection must support change notifications, it must notify LiveLinq when changes are made to its objects and when objects are added to or deleted from the collection. This requirement is satisfied for collections used for data binding, that is, implementing either IBindingList (WinForms data binding) or INotifyCollectionChanged/INotifyPropertyChanged (WPF data binding)

In particular, AsIndexed() is applicable to ADO.NET collections (DataTable, DataView) and to LINQ to XML collections.

More:

Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects)

Using ADO.NET data collections (LiveLinq to DataSet)

Using XML data (LiveLinq to XML)

Using bindable collection classes (LiveLinq to Objects)

LiveLinq to Objects: IndexedCollection<T> and other collection classes


Using the built-in collection class IndexedCollection

How to Use LiveLinq > How to query collections with LiveLinq

Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects)

Suppose first that we don't care what collection we use for our objects. We have a Customer class, something like

public class Customer

{

public string Name { get; set; }

public string City { get; set; }

}

and we rely on LiveLinq to supply the collection class we need.

Then we need look no further than the C1.LiveLinq.Collections.IndexedCollection class that is supplied by LiveLinq and is specifically optimized for LiveLinq use:

var customers = new IndexedCollection<Customer>();

customers.Add(cust1);

customers.Add(cust2);

...

var query =

from c in customers where c.City == "London" select c;

Note that we can simply use customers instead of customers.AsIndexed(). It is because the IndexedCollection<T> class already implements the IIndexedSource<T> interface that LiveLinq needs, there is no need to use the AsIndexed() extension method to wrap it into that interface.

There is an important consideration to be kept in mind using your own classes such as Customer above for collection elements. The Customer class above is so basic that it does not support property notifications. If you set one of its properties in code, nobody will notice it, including any indexes and live views you may create over that collection. Therefore it is highly necessary to provide property change notifications in such classes. Property change notifications is a standard .NET feature recommended for a variety of reasons, LiveLinq just adds another reason to do that. You can support property change notifications in your class by implementing the INotifyPropertyChanging and INotifyPropertyChanged interfaces. Or you can use LiveLinq for that, by deriving your class from IndexableObject and calling OnPropertyChanging/OnPropertyChanged like this:

public class Customer : IndexableObject

{

private string _name;

public string Name

{

get {return _name} ;

set

{

OnPropertyChanging("Name");

_name = value;

OnPropertyChanged("Name");

}

}

private string _city;

public string City

{

get {return _city} ;

set

{

OnPropertyChanging("City");

_city = value;

OnPropertyChanged("City");

}

}

}


Using ADO.NET data collections (LiveLinq to DataSet)

ADO.NET DataTable can also be used in LiveLinq, for example:

CustomersDataTable customers = ...

var query =

from c in customers.AsIndexed() where c.City == "London" select c;

For that, you’ll need to add

using C1.LiveLinq.AdoNet;

to your source file. The AsIndexed() used will be C1.LiveLinq.AdoNet.AdoNetExtensions.AsIndexed. It is specifically optimized for data in ADO.NET DataSets.


Using XML data (LiveLinq to XML)

LiveLinq can query data directly from XML in memory (stored in a LINQ to XML XDocument class). It dramatically speeds up LINQ to XML performance by supporting XML indexing (not supported by the regular LINQ to XML).

To use LiveLinq to XML, you need to add

using C1.LiveLinq.LiveViews.Xml;

to your source file.

Then you need to create some live views over your XML data. Unlike LiveLinq to Objects and LiveLinq to DataSet, where you can query data without live views, in LiveLinq to XML queries and live views are always used together. You are using LiveLinq to XML versions of LINQ query operators if you apply them to a live view. Otherwise, they will be the standard, not LiveLinq query operators. To start creating live views, simply apply the extension method AsLive() to an XDocument:

XDocument doc = …

View<XDocument> docView = doc.AsLive();

Once you have a live view, you can use the familiar (from LINQ to XML) query operators Elements, Descendants and others (see XmlExtensions Class) as well as all Standard Query Operators Supported in Live Views to define a live view. For example,

View<XElement> orders = docView.Descendants("Orders");

defines the collection of orders in the document. This collection is live; it is automatically kept up to date with the data in the XDocument that can be changed by your program. As a result, you can work with data in this collection in the same way as you would work with any dynamic collection, including ADO.NET DataTable or DataView. In particular, you can create indexes over it and use them for speeding up queries and for fast programmatic searches as shown in other sections of this documentation. It means that LiveLinq to XML makes it possible to work with XML data in memory without losing performance, so it is no longer necessary to create custom collection classes or use ADO.NET or other frameworks working with XML data. All you need is LINQ to XML with addition of LiveLinq.

Once you have some live views defined over XML data, you can query them. For example,

var query = from Order in orders.AsIndexed()

where (string)Order.IndexedAttribute("CustomerID") == "ALFKI"

gives you a query for orders of a particular customer.

Note. It is important to distinguish between live views and queries in LiveLinq to XML. Since you always start with a live view, your query will be a live view by default, unless you specify otherwise. In the example above, we used AsIndexed() to specify that we only need a query, don’t need that query to define a live view. Live views extend query functionality, so they can be used instead of queries. However, live views have performance overhead, so you should avoid using a live view where a simple query would suffice. As a general rule, avoid creating live views and throwing them away after using them just once to get results. Live views are designed to remain active (hence they are called live) and show up-to-date data.


Using bindable collection classes (LiveLinq to Objects)

Any bindable collection class (a class implementing change notifications for data binding) can be used in LiveLinq queries after it is wrapped in an IndexedCollection<T>-derived adapter class, which is done by applying a ToIndexed() extension method to it.

Using ToIndexed(), you can apply LiveLinq to various common data collections. For example, since the EntityCollection and ObjectResult classes of the ADO.NET Entity Framework are bindable, you can use ADO.NET Entity Framework data in LiveLinq queries and views.


LiveLinq to Objects: IndexedCollection

How to Use LiveLinq > How to query collections with LiveLinq

LiveLinq to Objects: IndexedCollection<T> and other collection classes

Querying general collection classes in LiveLinq is called LiveLinq to Objects, to distinguish it from LiveLinq to DataSet and LiveLinq to XML that query such specific data sources as DataSet and XML. So use LiveLinq to DataSet if you need to query data in a DataSet and LiveLinq to XML if your data is in XML. For other cases, we already saw two options in LiveLinq to Objects:

a. Use IndexedCollection<T> if you don't have preexisting collection classes and rely on LiveLinq to supply them.

b. Apply ToIndexed() to preexisting collection classes that support data binding.

And there is also a more advanced option that is not frequently needed:

c. Define your own collection class, usually derived from IndexedCollection<T>, if you want some non-standard functionality.

And finally, an option that can also be considered advanced, but, actually, is not particularly difficult, and allows you to bring virtually any collection into the LiveLinq orbit:

d. You can make any existing collection class C usable in LiveLinq provided that it somehow lets you know when changes occur. Then you can create an adapter class implementing the C1.LiveLinq.IObservableSource<T> interface and delegating most of its functionality to that preexisting collection class. Having an IObservableSource<T> implementation, you can apply the ToIndexed() extension method to it, it will return IIndexedSource<T>. LiveLinq extension methods implementing query operators take IIndexedSource<T> as their argument, see IndexedQueryExtensions.


How to create indexes

Now that we can query our collections in LiveLinq, we need to create some indexes for them, otherwise LiveLinq won't query them faster than the standard LINQ does.

Suppose we have a collection implementing IIndexedSource<Customer>, for example, like this:

var customers = new IndexedCollection<Customer>();

or like this:

var customers = CustomersDataTable.AsIndexed();

The IIndexedSource<T> interface has an Indexes collection (which is actually the only thing it has), so we use that collection to create an index like this:

var indexByCity = customers.Indexes.Add(x => x.City);

That creates an index of customers by city. Once the index is created, it will be automatically maintained on every change made to the customers collection. This maintenance comes with a performance cost. The cost is not high; index maintenance is fast and you can usually ignore it as long as you don't have too many indexes, but it may become a concern if you modify the collection very intensively.

To avoid heavy index maintenance cost, you can use the BeginUpdate/EndUpdate methods while making massive changes to a collection that has indexes attached to it, for example, while populating the collection.

This index will make queries such as

from c in customers where c.City == "London"

execute very fast because LiveLinq will use the index to go directly to the required items instead of searching for them by traversing the entire collection. Indexes can speed up many queries, not just this simple one, they can also speedup range conditions (with inequalities), joins, grouping, and other LINQ operators. See LiveLinq Query Performance: Tuning Indexing Performance for the full description of what classes of queries benefit from indexes.

Explicitly creating indexes by adding them to the collection as shown above is only needed if you want direct control over their lifetimes and/or direct access to the indexes (Index<T> objects) to use them programmatically (see How to use indexes programmatically). If all you need is to optimize a few LiveLinq queries, you can use the alternative, implicit method of creating indexes, using so called hints in LiveLinq queries. A hint .Indexed() is an extension method that can be applied to a property in a query. It does not change the value of that property; it only tells LiveLinq to create an index on that property (if possible). So, instead of creating an index by city explicitly as shown above, you could write the query like this:

from c in customers where c.City.Indexed() == "London"

That would tell LiveLinq to create an index by city if it has not been already created before. This hint does not affect the value of the property, that is, the value of c.City.Indexed() is the same as the value of c.City.


How to use indexes programmatically

Indexes are used by LiveLinq to optimize query execution, but they are also accessible for programmatic use. You can use indexes directly in code, calling methods of the Index<T> class to perform a variety of fast searches. This makes LiveLinq indexes useful even outside the framework of LINQ, outside queries.

For example, searching for a particular value can look like this:

indexByCity.Find("London")

or even like this:

indexByCity.FindStartingWith("L")

The Index<T> class also has other methods for performing fast searches and fast joins and groupings that can be useful in any code, not just in queries: FindGreater, FindBetween, Join, GroupJoin, and a few others.

Examples of programmatic searches (without LINQ) can be found in the LiveLinq indexing demo, see Query Performance sample application (LiveLinqQueries). In fact, every query that is shown in that demo has an alternative implementation via direct programmatic search in code without LINQ.


How to create a live view

Consider a simple query

from a in A where a.p == 1 select a

In standard LINQ, the result of this query is a snapshot. The result collection is formed at the time when the query is executed and it does not change after that. If one of its objects changes so it no longer satisfies the condition, that object will not be removed from the result collection. And if an object in A changes so it now satisfies the condition, that object will not be added to the result collection. The result of even such a simple query is not live, not dynamic, does not change automatically when the base collection A changes, not kept in sync automatically with the base data.

In LiveLinq, if we create a view based on that query, it will be live, dynamic, will change automatically when the base data changes, will be automatically kept in sync with the base data.

All we need to do to make a view out of this query is to use the extension method .AsLive():

var view = from a in A.AsLive() where a.p == 1 select a;

The AsLive() extension method is the analog of AsIndexed()/ToIndexed(), it can be used everywhere where the AsIndexed()/ToIndexed() extension methods can be used. So, live views are supported in all cases in LiveLinq to Objects, LiveLinq to XML and LiveLinq to DataSet (with some restrictions on the supported query operators, see Query Operators Supported in Live Views). The difference between AsIndexed()/ToIndexed() and AsLive() is that AsLive() creates a view, thus enabling LiveLinq both to query to populate the view and to maintain the view after it has been initially populated. The AsIndexed()/ToIndexed() extension methods do only the first part, enable LiveLinq querying.

The example above is a very simple one, it's just one simple Where condition. There are other tools that can do the same, for example, DataView in ADO.NET or CollectionView in WPF. The power of LiveLinq is that it supports most of the LINQ operators, including joins and others. So you can create a live view based not just on a simple condition, but on virtually any query you need.


How to bind GUI controls to a live view

LiveLinq views can be used as data sources for GUI controls because they implement the data binding interfaces so you can simply bind any control to it as to any other data source. For example, in WinForms:

View<T> view = from a in A.AsLive() join b in B.AsLive() on a.k equals b.k
where a.p == 5 select new {a, b};

dataGridView1.DataSource = view;

Data binding has long been the tool of choice for most developers creating GUI, but its scope was limited to simple cases only. You could bind to your base data, like your base collections, tables of a data set, etc, but not to your derived data, not to data shaped by some query. Some shaping was supported by some tools, but it was very limited, mostly just filtering and sorting. If you had data derived/shaped in any more complex way, for example, with joins (a very common case), you could not use data binding (more exactly, you could only use it for one-time snapshot binding, show data once, no changes allowed).

LiveLinq makes data binding extremely powerful by removing these limitations. Now you have the full power of LINQ to bind to.

With live views, you can create entire GUI, sophisticated applications, virtually without procedural code, using declarative data binding alone. An example of such application is the LiveLinqIssueTracker demo.


How to use live views in non-GUI code

Using live views is not limited to GUI. In a more general way, live views enable a declarative style of programming which we tentatively call view-oriented programming. Non-GUI, batch processing code can also be made declarative using live views.

Generally speaking, any application operates on some data, and any data can be seen as either based or derived data. Base data contains the main objects your application is dealing with, like Customers, Orders, Employees, et cetera. Those objects (collections containing all objects of a certain class, sometimes called the extent of a class) are the objects that your application modifies when it needs to make some change in the base data. But applications rarely operate on this base data directly, they rarely directly operate on the entire extent of a class. Usually they filter and shape those extents and combine them together to get to a slice of data they need for a particular operation. This shaping/filtering/joining/slicing of data is the process of getting derived data (as opposed to base, underlying data). Before the emergence of LINQ, it was done by purely procedural code, with all the ensuing complexity. LINQ made it declarative, which is a big step forward. But, although declarative, it is not live, not dynamic, and does not react to changes in base data automatically. Accordingly, its reaction to change is not declarative; the programmer needs to react to changes in procedural, imperative code. Complexity is diminished by LINQ, but reacting to change remains complex. And reacting to change is pervasive because change is everywhere.

LiveLinq live views make reacting to change declarative too, thus closing the circle of declarativeness. Now entire applications, not just GUI, can be made virtually entirely declarative.

To give just a small example, we can consider a sample in the LiveLinqIssueTracker demo. It has two operations performed on some issue data:

(1) Assign as many unassigned issues to employees as possible, using information on pending issues, product features (every issue belongs to a feature) and assignments.

(2) Collect information on open issues for given employees.

Each of these two operations (and in a real application there is, of course, many more operations like this) works on data shaped by a query with joins (see the actual queries in Live Views How To: Use Live Views to Create Non-GUI Applications as a Set of Declarative Rules Instead of Procedural Code). Both operations can be performed more than once during program execution. Data is changing while these and other operations on data are performed. Live views used to implement these operations change automatically with that changing data, so the operations can be kept simple and completely declarative, and as a result of that, robust, reliable and flexible, easily modifiable when business requirements change.

There is nothing else needed for this style of programming in addition to what we already know about how to create live views.


Getting Started Samples

These are the sample projects described in the Getting Started part of the LiveLinq documentation. You can create those projects yourself following the complete step-by-step instructions in Getting Started. The pre-created projects are included in the LiveLinq distribution package for your convenience.


HowTo Samples

The following sections describe LiveLinq's HowTo samples.

More:

Indexing samples

Live view samples


Indexing samples

HowTo Indexing samples demonstrate basic use of the first of the two areas of LiveLinq functionality: using indexes to make LINQ queries faster. They don’t use live views, except for LiveLinqToXml, where live views are necessary to define base data collections.

Every sample uses two queries: one the most basic and the other a little more complex, with a join. The queries are identical in functionality in all three samples, differing only in the nature of the underlying data: user object collections (LiveLinqToObjects), ADO.NET DataSet (LiveLinqDataSet) or XML (LiveLinqToXml).

Every sample shows two alternative ways of creating indexes: explicitly, by adding to the Indexes collection, or implicitly, by using hints in queries.

LiveLinqToObjects

This sample shows how to use the IndexedCollection class to create and query data collections using indexes to speed up query performance.

LiveLinqToDataSet

This sample shows how to use LiveLinq to query data residing in an ADO.NET DataSet, how to create indexes over that data that make querying faster than regular LINQ to DataSet queries. Both strongly typed and untyped datasets are demonstrated in the sample.

LiveLinqToXml

This sample shows how to use LiveLinq to query XML data. It creates indexes on ‘customers’ and ‘orders’ live views defined directly over XML data. This easy XML indexing allows to dramatically speed up LINQ queries over XML data, often make them hundreds of times faster than regular LINQ to XML, see Query Performance sample application (LiveLinqQueries) for performance metrics.


Live view samples

HowTo LiveViews samples show the second and main part of LiveLinq functionality: LINQ queries as live views, automatically reflecting changes in the data on which they are based, so they can be used to build applications declaratively, minimizing procedural, manual coding.

Every sample uses two views over the same data: one the most basic (filtered view) and the other a little more complex, with a join. The functionality is identical in all three samples, differing only in the nature of the underlying data: user object collections (LiveLinqToObjects), ADO.NET DataSet (LiveLinqDataSet) or XML (LiveLinqToXml).

To see live views in action, you can try, for example:

· Change the ShipCity value from "London" to "Colchester" or vice versa in any of the two grids and leave the current row (to commit the change). Observe that the value in the other grid changes accordingly.

· Change the ShipCity value to any string other than "London" and "Colchester" in any of the two grids. Observe that the row disappears from both grids.

See also the Live views sample application (LiveLinqIssueTracker) for more advanced functionality.

LiveViewsObjects

This sample demonstrates basic live view functionality for views based on user-defined object collections (LiveLinq to Objects).

LiveViewsDataSet

This sample demonstrates basic live view functionality for views based on ADO.NET DataSet (LiveLinq to DataSet). This sample uses a typed data set, but untyped data sets can be used as well, as shown in the LiveLinqToDataSet sample.

LiveViewsXml

This sample demonstrates basic live view functionality for views based on XML (LiveLinq to XML).


Sample Applications

The following sections describe LiveLinq's sample applications.

More:

Query Performance sample application (LiveLinqQueries)

Live views sample application (LiveLinqIssueTracker)


Query Performance sample application (LiveLinqQueries)

The querying demo shows all three LiveLinq varieties: LiveLinq to Objects, LiveLinq to DataSet and LiveLinq to XML, side by side, performing the same queries on the same data. The data are the good old Northwind Customers and Orders tables, in the three incarnations: custom object collections, a data set and XML, respectively.

The demo contains various queries, some with a parameter. For each query it shows the code, how that query is formulated in each of the three LiveLinq varieties. Every query is implemented in two different forms:

· Programmatic index search; that is, code without LINQ, directly using indexes for search, and

· LINQ query syntax.

These two LiveLinq implementations are compared with a standard LINQ implementation shown along with them. For each query, the demo shows the speedup factor: how much faster the LiveLinq implementation is compared with the standard LINQ one.


Live views sample application (LiveLinqIssueTracker)

This demo shows how live views can be used to construct entire GUI applications based almost entirely on declarative queries/views and data binding, with little procedural code. It also contains an example of how live views can be used in non-GUI, batch, perhaps server-side processing.

It is a mockup bug/issue tracking application in a fictitious company that produces Shakespeare's plays. The demo comes in three variations, each built on top of a different data store: Collections (uses LiveLinq to Objects), ADO.NET (uses LiveLinq to DataSet) and XML (uses LiveLinq to XML). It uses WinForms data binding, but WPF data binding could be used instead just as well and the live views would be exactly the same.

The data schema contains Products (each product is a Shakespeare's play). Each product has features (which, incidentally, are roles in the play). And there are Issues, in other words, bugs (such as bad acting in a certain scene). Also, there are Employees who are assigned those issues (incidentally, those employees are actors playing those roles), and, an important part of this schema, there are Assignments: every employee is assigned a certain number of features to take care of. These assignments can overlap, meaning that more than one employee can be assigned to a feature.

When we start the application and open the Assigned Issues form, we can see issues assigned to any given employee. The view representing it is (we are giving LiveLinq to DataSet versions of the views here, Objects and XML versions are similar):

from i in _dataSet.Issues.AsLive()

join p in _dataSet.Products.AsLive()

on i.ProductID equals p.ProductID

join f in _dataSet.Features.AsLive()

on new { i.ProductID, i.FeatureID }

equals new { f.ProductID, f.FeatureID }

join e in _dataSet.Employees.AsLive()

on i.AssignedTo equals e.EmployeeID

where i.AssignedTo == employeeID

select new Issue

{

IssueID = i.IssueID,

ProductName = p.ProductName,

FeatureName = f.FeatureName,

Description = i.Description,

AssignedTo = e.FullName

};

It is a non-trivial LINQ query, with joins and filtering, and the demo shows that it is live, dynamic, automatically reacts to changes in data, and that GUI controls such as DataGridView can be bound to it.

For example, if we add an issue in the Add Issue form and assign it to the same employee that is shown in the Assigned Issues form, the list of issues for that employee is automatically updated to include the newly created issue.

The Assigned Issues form also demonstrates the difference between Immediate and Deferred maintenance mode, allowing switching between them with two radio buttons. If we switch to the Deferred mode, meaning update on demand, and add an issue, that change is not immediately reflected in the view; it is reflected only when we request data from that view, for example, by changing the employee and then changing it back.

There is also a (Re)assign Issue form that uses basically the same view, so, without writing code using only live views and data binding, we can do things like assign and reassign issues.

Assigned Issues and (Re)assign Issue forms can be opened in any number of instances side by side. You can experiment with opening several forms like that, re-assigning issues in one of them, and then observe the changes automatically reflected in all others.

The demo also shows some actions more complicated than that, such as how live views can change more than just one row at a time. There is a form called All Issues Concerning an Employee that shows all issues for all features assigned to a particular employee using the following view:

from a in _dataSet.Assignments.AsLive()

join p in _dataSet.Products.AsLive()

on a.ProductID equals p.ProductID

join f in _dataSet.Features.AsLive()

on new { a.ProductID, a.FeatureID }

equals new { f.ProductID, f.FeatureID }

join i in _dataSet.Issues.AsLive()

on new { a.ProductID, a.FeatureID }

equals new { i.ProductID, i.FeatureID }

join e in _dataSet.Employees.AsLive()

on i.AssignedTo equals e.EmployeeID

where a.EmployeeID == employeeID

select new Issue

{

IssueID = i.IssueID,

ProductName = p.ProductName,

FeatureName = f.FeatureName,

Description = i.Description,

AssignedTo = e.FullName

};

Assignments of features to an employee can be changed in a (Re)assign Features form. You can experiment with changing the set of features assigned to an employee and see how the changes, which can be quite massive, automatically occur in the All Issues Concerning an Employee form. And although it's not easy to see with such a small data set (unless you add thousands of issues to it, which likely would be the case in a real-life application), the changes to the views shown in the grids are fast, without delays for re-querying the views and refreshing the entire grid, thanks to the incremental view maintenance algorithms implemented in LiveLinq.

The demo also shows how to create views based on other views and how to create indexes on views, see Live Views How To: Create Views Based on Other Views and Create Indexes on Views, and how to use live views to create non-GUI applications as a set of declarative rules instead of procedural code, see Live Views How To: Use Live Views to Create Non-GUI Applications as a Set of Declarative Rules Instead of Procedural Code.


Programming Guide

The following sections provide information concerning LiveLinq programming.

More:

Query Operators Supported in Live Views

Query Expressions Supported in Live Views

View Maintenance Mode

Updatable Views

Live View Performance

LiveLinq Query Performance: logical optimization

LiveLinq Query Performance: Tuning Indexing Performance

Live Views How To: Create Views Based on Other Views and Create Indexes on Views

Live Views How To: Use Live Views to Create Non-GUI Applications as a Set of Declarative Rules Instead of Procedural Code


Query Operators Supported in Live Views

LiveLinq supports all LINQ query operators in its queries. Not all operators have LiveLinq-specific implementation benefiting from indexes and other query execution optimization techniques, but such operations simply use the standard LINQ to Objects (or LINQ to XML) implementations, so it is transparent to the user.

However, not all query operations can be used in live views. This is because not all query operations have incremental view maintenance algorithms, as some would require re-populating from scratch (requerying) every time they are maintained. If your query contains such operations, you won't be able to use that query to create a live view. An attempt to do that will cause a compilation error.

Here is the list of query operators allowed in live views:

Operator | Notes
Select | Overload with selector depending on the index is not allowed.
Where | Overload with predicate depending on the index is not allowed.
Join | Overload with comparer is not allowed.
GroupJoin | Overload with comparer is not allowed.
OrderBy | Overload with comparer is not allowed.
OrderByDescending | Overload with comparer is not allowed.
GroupBy | Overloads with comparer and with resultSelector are not allowed.
SelectMany | Overloads with selector and collectionSelector depending on the index are not allowed.
Union |
Concat |
Aggregate | Use LiveAggregate if you want to optimize performance with incremental view maintenance.
Count | Use LiveCount if you want to optimize performance with incremental view maintenance.
Min/Max | Use LiveMin/LiveMax if you want to optimize performance with incremental view maintenance.
Sum | Use LiveSum if you want to optimize performance with incremental view maintenance.
Average | Use LiveAverage if you want to optimize performance with incremental view maintenance.


Query Expressions Supported in Live Views

Apart from the limitations on query operators, a query must satisfy an additional condition in order to be used as a live view. Fortunately, this condition is satisfied in most cases, so you should care about it only if your query contains some special expressions, which is relatively rare (except that all classes used in LiveLinq to Objects must satisfy the property notification condition, but that was already mentioned in Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects)). Unfortunately, this condition is not verified by LiveLinq automatically, so it is your responsibility to make sure it is satisfied. If this condition is not satisfied, your view will not react to changes in its base data. We give two descriptions of this condition: one short, for basic understanding, and another detailed, for advanced usage.

Short Description

The short answer is, basically, that in some cases your classes need to provide property notifications. There are two such cases where you need to care about that:

(1) LiveLinq to Objects.

There your views' arguments are collections of your own classes, so you must make sure that your classes provide property notifications, otherwise your views will not react to changes of those properties,(see Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects).).

(2) Views over views and indexes over views (applies to LiveLinq to DataSet and LiveLinq to XML as well as to LiveLinq to Objects).

If you have a view

View<T> v;

and want to create another view over view v (use v as its argument) or create an index over v, then make sure that the T class has property notifications, otherwise the view (or index) you define over v will not react to changes of those properties.

Note for LiveLinq to DataSet and LiveLinq to XML: If the view result class T is (or is derived from) DataRow (for LiveLinq to DataSet) or XNode (for LiveLinq to XML), then property notifications there are not needed (so there are no conditions or restrictions in this case, it just works), LiveLinq gets the notifications it needs from the standard events.

Also, it can be mentioned here that you don't need to care about these conditions if the properties of your objects are not changed by your code in other ways than automatically by LiveLinq itself; that is, if you don't have code setting properties of the objects that are elements in the source collections of your views. In particular, if your classes have read-only properties, which includes all anonymous classes, that are often used in LINQ. It is also the case if you use structs, that is, value types (as opposed to classes, reference types), because value types are not references, so you can't change the elements of your collection. In all these cases there is no need in change notifications.

And finally, here is what you need to avoid: A possible source of errors is using property chains, such as for an Order class with a Customer property:

o => o.Customer.City

You can do it if you do not modify the City property in Customer objects. But if you have code changing the City property, LiveLinq will not reflect the change, because the Order object usually does not notify it of changes in Customer objects. Note that you can usually modify the query so it has the same effect without using property chains. For example, instead of

…Select(o => o.Customer.City)

use

…Select(o => o.Customer).Select(c => c.City)

Detailed Description

Observable and non-observable functions

Our condition limits the choice of functions (such as result selector, key selector, et cetera) that you can use in your query expression depending on whether or not your classes support property notifications, see Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects).

The property notifications we are talking about are those in the element classes of your view's arguments, not in the class of your view's result (but, of course, one view's result can be another view's argument, since views can be created based on views).

We distinguish two types of functions: observable and non-observable. Observable functions are allowed, non-observable functions must be avoided.

1. Observable functions.

A function (expression) is observable if the only non-constant sub-expressions it contains are property or method calls whose values are observable in the sense that any change of that value is always accompanied by the change notification events.

Examples of observable functions:

x => x.P1

x => x.P1 + x.P2 + x.M(c1)

(x, y) => new {x.P1, x.P2, M = y.M(), y.P3}

Here P1, P2, P3, M are properties/methods with change notifications, and c1 is a value that never changes.

Note for advanced usage: Property/method call is understood here to include not only one applied directly to one of this function's parameters, but also, recursively, to the parameters of a function preceding this function in the query, if they can be reached through (possibly a chain of) simple references in object initializers. For example,

....Select((x, y) => new { P1 = x, P2 = y }).Select(z => new { z.P2.A, z.P1.B })

is allowed (if, of course, properties A and B are observable).

1a. Constants are also observable.

Note that we specifically excluded constant values from the condition above. Any constant values/objects are allowed in a function and don't break its observability. By "constant value", we mean that it remains the same object for every given parameter value. In other words, it does not change with time. The most common example of a constant is the identity function:

x => x

Although the state of the object can change with time, the object itself, as well as the reference to it, stays the same (for a given parameter object, of course, which in this case is the same as the result object), therefore it is a constant. Other examples of constants are:

x => c1

(x, y) => new {x, y}

(x, y) => x + y

x => x == c1 ? c2 : c3

where c1, c2, c3 are some constant values.

Constant values can be combined in the same function with observable values, and the resulting function remains observable, for example:

x => new {x, x.P1, P = y.P2 + y.P3 }

where P1 and P2 are properties with change notifications.

1b. Object initializers and constructors that don't depend on the arguments are allowed.

The previous examples included only new with anonymous classes, but, in fact, user-defined classes and constructor calls are also allowed without breaking observability, as long as you don't use the function arguments in the constructor, using only constant expressions or nothing at all (a parameterless constructor or an object initializer). So, the following functions are observable (where c1 is a constant value and P and Q are observable properties):

(x, y) => new C { x.P, y.Q}

(x, y) => new C(c1) { X = x, P = y.P }

and the following are non-observable:

(x, y) => new C(y) { x.P, y.Q}

(x, y) => new C(c1, x) { x, y.P }

2. Non-observable functions.

As the name suggests, any function that does not satisfy the condition above is considered non-observable. Note that this condition of observability depends not only on the function itself but also on the class of the argument of that function; that class must have property change notifications for everything that is used in the function that is not constant. So, even the simplest functions, such as x => x.P can be non-observable if P is non-observable (that is, the class does not issue change notifications for P). So, the first and most common examples of non-observable functions are the same as above but in situations where at least one of the properties P1, P2 is not observable, that is, the class does not provide change notifications for it:

x => x.P1

(x, y) => new {x.P1, y.P2 }

This can occur if you simply forgot to add the code providing notifications (see Using the built-in collection class IndexedCollection<T> (LiveLinq to Objects)).

Another possible cause is a property returning a calculated value, like in

public class Customer

{

public List<Order> orders;

public int OrderCount { get {return orders.Count;} }

}

unless you specifically take care to issue a property change notification in the Customer class every time its orders.Count changes.

Yet another possible cause is using a chain of properties, like, for an Order class with a Customer property:

o => o.Customer.City

Note that any expression, including the two above, can be made observable if you take special care to trigger property change notification every time its value changes, but it requires code written specifically for that purpose. For example, with the last function, you can trigger property change notification events for the Orders collection every time the City property in the Customer class changes.


View Maintenance Mode

Live views can be used in different kinds of applications. They can be used in GUI, interactive applications and in non-GUI, batch processing-style applications (see How to use live views in non-GUI code). Live views are optimized for both modes, GUI (interactive) and non-GUI (batch). They distinguish between these modes and operate accordingly. In GUI, live views react to a change immediately when the change happens. They do it fast, using incremental algorithms without re-populating themselves, (see Maintaining the view: Incremental View Maintenance), but still it is not always suitable for batch, non-interactive processing. In GUI, interactive programs, with data binding, immediate reaction to change is what is usually needed because the user needs to see the change on the screen. In batch processing, on the other hand, a view may be accessed long after the change occurred or even not at all. So updating that view before it is actually accessed by the program may be an unnecessary drain on resources. By default, live views distinguish between these two modes automatically, but the programmer has an option to control that using the MaintenanceMode property. In Immediate mode, which is the default for GUI, the view is maintained immediately on every change. In Deferred mode, which is the default in a non-GUI case (when there are no listeners attached to the view), the view is maintained on demand. It is not kept in sync with base data until it is needed or until there is a request for data from that view. When such a request arrives, the view sees that it is in a "dirty" unsynchronized state, so it automatically updates (maintains) itself to come in sync with the changed base data.


Updatable Views

Live views are bi-directionally updatable. The first direction is from base data to the view: the base (source) data can be modified and the view will be automatically updated and then synchronized with the changed base data. That is what makes the views live. There is also the second, opposite direction: data can be changed directly in the view. This can be done programmatically (using the ViewRow class), and it can also be done via data binding. Updating data directly in the view is especially common if you bind a GUI control, such as a grid, to a view. An example of updating data in a view via data binding can be seen in one of the first samples, Basic LiveLinq Binding, among others.

We call a view updatable if data can be modified directly in the view. This term only concerns the second direction of updating data. The first direction mentioned above, updating base data, is always possible without restrictions for any live views. So, when we say that a view is not updatable (is read-only), it does not mean that the data in the view cannot change. It can change to reflect changes in base data because every view in LiveLinq is live. It merely means that data cannot be changed directly in the view, you need to change base data if you want to modify it.

Not all live views are updatable, and even if the view as a whole is updatable, some properties of it may be read-only. These are properties that don't have direct correspondence to a property in the view's source data. Updating a view ultimately means updating that view's base data, that is, one of the view's sources, because the view itself is only virtual, does not have data of its own, shows (filtered and shaped) data of its sources. This is why a view field (property) can be updated only if it can be put into a direct correspondence with a property in the source. For example, in the following view

for c in customers where c.City == "London"

select new

{

c.City,

c.CompanyName,

FullName = c.FirstName + " " + c.LastName

}

City and CompanyName are updatable because they directly correspond to the City and CompanyName fields of the customers source. But FullName is not updatable, because there is no single field (property) in the source to which it corresponds, it is a combination of two source properties.

Any update of a view, which can be adding, deleting or modifying a view item, is performed by performing the corresponding operation, adding, deleting or modifying a single item in one of the view's sources. Although the effect is usually obvious and it usually does what is intended, it is important to know this simple rule, to understand it formally and exactly, because the result can sometimes be unexpected if you don't take this rule into account. For example, if you modify an item (or add a new one) in the above view so its City value is not "London", that item will disappear from the view.

The above rule stating that updating a view item is equivalent to updating an item of one of the view's sources, implies that only one of the view's sources can be updatable. A Join view has two sources, so we must determine which of them is updatable. By default, a join view is read-only. If you need to make one of its two parts updatable, use the extension method AsUpdatable(), for example:

for o in orders.AsUpdatable()

join c in customers on o.CustomerID equals c.CustomerID

select new

{

o.OrderDate,

o.Amount,

c.CompanyName

}

Here order data (date and amount) will be updatable and customer data (CustomerName) read-only.

To find out if a view is updatable, use the property View.IsReadOnly. The list of all properties of a view accessible to data binding and programmatic access, with full information including their updatability, can be obtained using the property ViewRowCollection.Properties.

Updating data directly in a view in code is done through a special class ViewRow, each view row representing a view item for programmatic access and data binding purposes. For details of using this class in code see reference documentation for ViewRowCollection and ViewRow.


Live View Performance

First performance consideration with live views is that, naturally, live view functionality has a price. Maintaining the view in sync with base data is fast and optimized, but still it consumes some resources when base data changes and the view is maintained. And it consumes some additional resources when it is first populated as well. That additional cost is not high, but it exists, manifesting itself mostly in additional memory consumption: when a live view is populated, it creates some internal data in memory to help it maintain itself faster on base data changes.

This additional memory consumption is moderate—roughly equivalent to the amount of memory needed for the resulting list itself. So, although additional resources needed for live view functionality are light to moderate, the obvious suggestion is to use live views only where you are really interested in keeping the result of a query live, or, in other words, where you need that result more than once and the base data is changing so that the result is changing too.

Other than this, there are two different aspects to live view performance:

Populating the view: query performance

Query performance is how long it takes to populate the view for the first time by executing the query (or re-populate by re-executing the query, see View.Rebuild). This is covered in LiveLinq query performance: logical optimization and LiveLinq Query Performance: Tuning Indexing Performance.

Maintaining the view: Incremental View Maintenance

Maintaining live views on base data changes is optimized using techniques known as Incremental View Maintenance. It means that a view does not simply re-populate itself, it adjusts to accommodate base data changes in a more smart way. The changes to the view are made locally, incrementally, calculating the delta in the view from the delta in the base data. In most cases, it is very fast and does not require any special performance tuning from the user.

As a guideline to estimating the time of view maintenance, we can say that it is roughly proportional to the number of changed items (including added and deleted ones) in the view's resulting collection. So, if only few items change as a result of a change in base data, the view maintenance time is very small and probably negligible, but it can be considerable if a considerable part of the view result changes. It can even become more costly to maintain a view than to re-query it from scratch, if, for example, half of the resulting list changes.

Finally, it is worth noting that maintenance performance for a view does not depend on its query performance. It does not matter how long it takes to populate the view initially; maintenance time is roughly the same and depends on the size of the change in (delta) and not on the size of the overall data.


LiveLinq Query Performance: logical optimization

Standard LINQ to Objects does not perform any logical optimization, it executes queries exactly as they are written. And, of course, standard LINQ to Object does not use indexes for optimization. In comparison, LiveLinq performs physical optimization (using indexes, if they are present) and logical optimization (re-writing the query in a more efficient form before processing it).

However, LiveLinq does not contain a full-scale query optimizer like one in a relational database such as SQL Server or Oracle, so it can still matter how a query is written. But it is largely limited to join ordering. LiveLinq does not try to re-order your joins. Joins are executed always in the same order as specified in the query. So, you should avoid writing queries with obviously inefficient join order. But it must be noted that it is a relatively rare problem (and the same consideration, of course, applies to the standard LINQ to Objects anyway). It can be an issue in a query like

from a in A

join b in B on a.k equals b.k (1)

where b.p == 1

if there are, for example, only 10 elements in B with b.p == 1 and only 100 elements in A that satisfy a.k == b.k and b.p == 1, but the overall number of elements in A is many times higher, for example, 10000. Then the query above will require 10000 "cycles", whereas rewritten with the right join order,

from b in B

join a in A on b.k equals a.k (2)

where b.p == 1

this query will require only 100 cycles to complete. Note that the position of where is not important. The above query has the same performance as

from b in B

where b.p == 1 (3)

join a in A on b.k equals a.k

That's because of LiveLinq query optimization: LiveLinq re-writes (2) internally to (3) when it executes it, because it is preferable to check conditions before performing other operations and to exclude elements that don't contribute to the result. This is one of the logical optimizations performed by LiveLinq internally.


LiveLinq Query Performance: Tuning Indexing Performance

Query speedup achieved on any particular query by LiveLinq using indexes for optimization depends on how that query is written. This dependence is usually not dramatic. LiveLinq does a fair job of recognizing opportunities to use indexes for optimization regardless of the way the query is written. For example, it will still execute a query efficiently using indexes even if the condition consists of multiple terms connected with logical operators.

If you want to ensure that your indexes are used effectively by LiveLinq, consider the following guidelines:

Elementary predicates that can benefit from indexing

LiveLinq can use an index by a property P in an elementary predicate (a condition without boolean operations) that has one of the forms (patterns) (1) – (6) listed below. The simplest and perhaps the most common of such elementary predicates is a where condition with an equality involving a property, as in

from x in X where x.P == 1 select x

It will use the index by x.P provided that such index exists, which, as described in How to create indexes, can be ensured either by creating this index explicitly

X.Indexes.Add(x => x.P);

or by using the Indexed() hint:

from x in X where x.P.Indexed() == 1 select x

In fact, LiveLinq supports a more general indexing. It does not necessarily have to be a property of x, it can be any expression depending on x (and only on x). This can come in handy, for example, if we are querying an untyped ADO.NET DataTable, so, because it is untyped, it does not have properties that we can index and query by their names and we need to use a query like this:

from c in customersTable.AsIndexed() where c.Field<string>("CustomerID") == "ALFKI" select x

Then we can use an index by the following expression:

X.Indexes.Add(c => c.Field<string>("CustomerID"));

We will quote only the most common case of a simple property, x.P in the list below, but keep in mind that it can be replaced everywhere with any expression depending on x (and only on x).

Following is the list of patterns recognized by LiveLinq as allowing optimization with indexes:

(1) Equality:

x.P == Const (Const is a value constant in the given query operator, which means that it can be an expression depending on external parameters and variables, but it must have the same value for all elements that are tested by this where condition).

Example:

from o in Orders.AsIndexed() where o.OrderID.Indexed() == 10011

(2) Inequality:

x.P op Const, where op is one of the comparison operators: >, >=, <, <=

Example:

from o in Orders.AsIndexed() where o.OrderID.Indexed() > 10011

(3) Left and right parts of an equality or inequality are interchangeable (commutative).

Example: The following query will use indexing exactly as the one in (1):

from o in Orders.AsIndexed() where 10011 == o.OrderID.Indexed()

(4) StartsWith:

x.P.StartsWith(Const), if x.P is of type string.

Example:

from o in Orders.AsIndexed() where o.CustomerID.StartsWith("A")

(5) Belongs to (in, is an element of):

ConstColl.Contains(x.P), if ConstColl implements IEnumerable<T> where T is the type of x.P.

Example:

from o in Orders.AsIndexed()
where (new int[]{"ALFKI", "ANATR", "ANTON"}).Contains(o.CustomerID)

(6) Year comparison:

x.P.Year op Const, where x.P is of type DateTime and op is any of the comparison operators ==, >, >=, <, <=

Example:

from o in Orders.AsIndexed()
where o.Date.Indexed().Year == 2008

Other elementary predicates don't use indexes. Examples where indexing will not be used:

from o in Orders.AsIndexed() where o.Freight > 10

(if there is no index defined for the Freight property)

from o in Orders.AsIndexed() where o.OrderID.Indexed() < o.Freight

(comparison must be with a constant, not with a variable value)

from o in Orders.AsIndexed() where o.OrderID.Indexed() != 10011

(only certain comparisons are used, ! (not equal) is not one of them)

Boolean operators

Conjunction (&&) and disjunction (||) are handled by LiveLinq optimizer, including their arbitrary combinations and including possible parentheses. Other boolean operators, such as negation (!) are not handled by the optimizer; they block its use of indexing.

Conjunction:

Conjunction does not prevent the use of indexes. For example,

from o in Orders.AsIndexed() where o.Freight > 10 && o.Lines.Count > 5

will use the index by Freight property (supposing such index exists) even though the second condition cannot use indexes. LiveLinq will simply check the other condition for each item that is found using the index from the first condition.

Conjunction of conditions using the same property

Moreover, conjunctions of conditions with the same property will be optimized to render the best execution plan. For example, if the Freight property is indexed,

from o in Orders.AsIndexed() where o.Freight > 10 && o.Freight < 20

will not go through all orders with Freight > 10 and check if it is less than 20 for each of them but will use the index to go directly to the orders between 10 and 20 and won't check any other orders.

Conjunction of conditions with different properties: where subindexes come into play

Conjunctions using different properties, for example

from o in Orders.AsIndexed() where o.CustomerID == "ALFKI" && o.Freight < 20

can utilize subindexes, see Subindex(T, TKey) Class. If the index by CustomerID has a subindex by Freight, LiveLinq will not check all orders with CustomerID equal to "ALFKI" (which can be quite numerous). It will go directly to the subindex corresponding to the value "ALFKI" (only one such subindex exists, and it can be accessed directly, without any search) and enumerate the items in that subindex whose Freight is less than 20. Both operations (finding a subindex and enumerating a range of items in it) are direct access operators, without search, so the query is executed in the fastest way possible, without spending any time on checking items that don't contribute to the result.

Disjunction:

(a) For an indexed property x.P,

x.P == Const1 || x.P == Const2

is handled by re-writing the condition as

(new ...[]{Const1, Const2}).Contains(x.P)

(b) If two different properties x.P and x.Q are indexed, then

x.P op Const1 || x.Q op Const2 (op is ==, <, >, <=, etc)

is handled by re-writing the query as a union of two separate queries with corresponding elementary conditions.

Join

If either of the two key selectors in a join, that is, either x.K or y.K in

from x in X

join y in Y on x.K equals y.K

is indexed, LiveLinq will use that index to perform the join.

Ideally, both x.K and y.K are indexed, and then LiveLinq will execute the join in the fastest way possible (using the so called merge join algorithm, which is very fast; basically, it takes the same time to build as to traverse the result of such join, there is no time lost on anything).

If there are no indexes on x.K or y.K, LiveLinq will still try to find the best algorithm for the join, which is sometimes merge join (if both parts of the join are ordered by the merge key) and sometimes the hash join algorithm used by the standard LINQ to Objects.

As a general guideline, it should be noted that defining indexes only for optimizing Join operations in your query will rarely lead to dramatic speedups. That's because the hash join algorithm (the one used in the standard LINQ, it does not need indexes) is already quite fast. It does make sense to define indexes for join keys sometimes, but consider it when you are fine-tuning your query, not when you need the first quick and dramatic speedup. For dramatic speedups, first consider optimizing your Where conditions, that can speed up your query often hundreds and even thousands times (depending on the query, of course).


Live Views How To: Create Views Based on Other Views and Create Indexes on Views

Multiple queries with parameters can often be replaced with a single “big” live view. That can help making code clear and simple and can often make it faster. This technique is based on two features of live views:

· A view can be based on other views in the same way as it can be based on base data.

· Indexes can be created for a view in the same way as indexes are created for base data.

So, instead of issuing many queries by varying a parameter value, you can create a single live view, create an index for it, and, when you need the list of items corresponding to a particular value of the parameter, you simply get those items from the index for that particular value.

It is illustrated in the LiveLinqIssueTracker demo:

The Assigned Issues form uses multiple views, a separate view for every employee: views depending on a parameter employeeID (we are giving LiveLinq to DataSet versions of the views here, Objects and XML versions are similar):

from i in _dataSet.Issues.AsLive()

join p in _dataSet.Products.AsLive()

on i.ProductID equals p.ProductID

join f in _dataSet.Features.AsLive()

on new { i.ProductID, i.FeatureID }

equals new { f.ProductID, f.FeatureID }

join e in _dataSet.Employees.AsLive()

on i.AssignedTo equals e.EmployeeID

where i.AssignedTo == employeeID

select new Issue

{

IssueID = i.IssueID,

ProductName = p.ProductName,

FeatureName = f.FeatureName,

Description = i.Description,

AssignedTo = e.FullName

};

The demo application also contains an alternative implementation of the same functionality, in the form Assigned Issues 2. That form uses a single view containing data for all employees, instead of multiple views depending on a parameter. This single view does not have parameters:

_bigView =

from i in _dataSet.Issues.AsLive()

join p in _dataSet.Products.AsLive()

on i.ProductID equals p.ProductID

join f in _dataSet.Features.AsLive()

on new { i.ProductID, i.FeatureID }

equals new { f.ProductID, f.FeatureID }

join e in _dataSet.Employees.AsLive()

on i.AssignedTo equals e.EmployeeID

select new Issue

{

IssueID = i.IssueID,

ProductName = p.ProductName,

FeatureName = f.FeatureName,

Description = i.Description,

AssignedToID = e.EmployeeID,

AssignedToName = e.FullName

};

That view is indexed by the employee id field:

_bigView.Indexes.Add(x => x.AssignedToID);

so we can retrieve the items for a particular employee id at any time very fast.

Moreover, we can create a live view of that data given an employee id value (which is comboAssignedTo.SelectedIndex in this demo), simply by creating a view over the big view:

from i in _bigView where i.AssignedToID == comboAssignedTo.SelectedIndex select i;


Live Views How To: Use Live Views to Create Non-GUI Applications as a Set of Declarative Rules Instead of Procedural Code

In addition to making GUI applications declarative, LiveLinq also enables a programming style (which we tentatively call view-oriented programming) that makes non-GUI, batch processing declarative too. See How to use live views in non-GUI code for the introductory description of this technique.

The LiveLinqIssueTracker demo application contains a Batch Processing form where this technique is demonstrated by implementing two actions:

(1) Assign as many unassigned issues to employees as possible. Looking at the feature to which a particular issue belongs, find an employee assigned to that feature, and, if that employee does not have other issues for that feature, assign that issue to that employee.

(2) Collect information on all open (not fixed) issues for a given employee (perhaps for the purpose of emailing that list to that employee).

We perform action (1) by defining the following view (we are giving LiveLinq to DataSet versions of the views here, Objects and XML versions are similar):

_issuesToAssign =

from i in issues

where i.AssignedTo == 0

join a in _dataSet.Assignments.AsLive()

on new { i.ProductID, i.FeatureID }

equals new { a.ProductID, a.FeatureID }

join i1 in issues

on new { i.ProductID, i.FeatureID, a.EmployeeID }

equals new { i1.ProductID, i1.FeatureID, EmployeeID = i1.AssignedTo }

into g

where g.Count() == 0

join e in _dataSet.Employees.AsLive()

on a.EmployeeID equals e.EmployeeID

select new IssueAssignment

{

IssueID = i.IssueID,

EmployeeID = a.EmployeeID,

EmployeeName = e.FullName

};

and performing the operation with simple code based on that view:

foreach (IssueAssignment ia in _issuesToAssign)

_dataSet.Issues.FindByIssueID(ia.IssueID).AssignedTo = ia.EmployeeID;

Action (2) is performed by defining the following view:

from i in _dataSet.Issues.AsLive()

join p in _dataSet.Products.AsLive()

on i.ProductID equals p.ProductID

join f in _dataSet.Features.AsLive()

on new { i.ProductID, i.FeatureID }

equals new { f.ProductID, f.FeatureID }

join em in _dataSet.Employees.AsLive()

on i.AssignedTo equals em.EmployeeID

where i.AssignedTo == employeeID && !i.Fixed

select i.IssueID;

If we need to perform the operations (1) and (2) just once, then there is no point in using live views. But suppose we are writing a program that needs to perform those actions (1) and (2) many times as steps of the overall algorithm it is executing. This is a common case, especially in server-side programming.

Without live views, we would either need to requery each time, which is very costly, or we would need to create and maintain some collections throughout our processing algorithm. Those collections would need to be maintained by manual code, often complicated, and written by different programmers and often containing bugs. Different people write different functions (actions (1) and (2) are, of course, just two small examples of such functions), they need to know what others are doing if they want to keep it consistent. All this is hard to maintain. When a new action or function is added a year after that, the logic that connects everything is by that time forgotten, the new action breaks that logic, and so the vicious cycle of too complicated programming goes on.

Compare this with how it can be done with live views:

Actions (1) and (2) are not actually procedures, they are declarative rules. Rule (1) states that this view contains the assignments to be made. Whatever changes are made to our data, this view will always contain the needed assignments, regardless of anything we add a year from now or at any other time. The logic is guaranteed to be correct because it is a declarative rule, not procedural logic.

And that rule (1) works fast. We can perform that action a thousand times over data that is always changing, and every time it will recompute only the required amount of data, only the amount that is affected by changes. It will perform only the needed incremental recomputations.

Same with rule (2): it is a declarative rule, and it executes fast without repeating calculations, recalculating only those parts that are affected by changes.

If a substantial part of our algorithm is programmed in this view-oriented way, as a set of rules like (1) and (2), then they all work together, their consistency is automatically maintained. Ideally, we can represent our entire algorithm with views/rules like that. If not, a part of it can be implemented like that and the rest can be done with the usual procedural code.


C1.LiveLinq Namespace

[image]

.NET Framework Class Library
C1.LiveLinq Namespace

Classes

Class | Description
CompiledQuery | Provides for compilation and cache of queries for reuse.
DeletedStateIsAvailableAttribute | Indicates that the properties of an object of a class still return correct property values after the object has been deleted from the collection it belonged to.
Hints | Provides a static (extension) method used as a hint that can be applied to an expression (usually, a property) in a query.
IndexedQueryExtensions | Provides a set of static (extension) methods for querying objects that implement IIndexedSource<(Of <(T>)>).
LiveViewExtensions | Provides a set of static (extension) methods used in queries to define live views.
Ordering<(Of <(T>)>) | Represents a sorted IIndexedSource<(Of <(T>)>).
QueryOptimizationException | Represents an exception that is thrown when Hints in a query require using a certain mandatory optimization which is impossible in the current query context.
SourceChangeEventArgs<(Of <(T>)>) | Provides data for the Changing and Changed events.

Interfaces

Interface | Description
IObservableSource<(Of <(T>)>) | Provides methods and events that are required for LiveLinq functionality, indexing and live views.

Enumerations

Enumeration | Description
IndexingHintAction | Specifies the actions taken by LiveLinq query optimizer when it encounters an Indexed() hint applied to an expression (usually, a property) in a query.
Order | Indicates if a certain order is required in the result collection of an operation.
SourceChangeType | Describes a change occurring in a collection.


CompiledQuery Class

[image]

.NET Framework Class Library
CompiledQuery Class
Members See Also
Provides for compilation and cache of queries for reuse.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class CompiledQuery
Visual Basic (Declaration)
Public NotInheritable Class CompiledQuery

Remarks

If you need to execute the same query many times, each time with different parameter values, use the CompiledQuery class to improve performance. Without it, every query execution includes a compilation stage, that does not take much time but that time can accumulate to significant numbers if it is repeated many times. The CompiledQuery class contains a single Compile method with several overloads. Call the Compile method to create a delegate to represent the compiled query.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq..::.CompiledQuery

See Also

CompiledQuery Members
C1.LiveLinq Namespace


CompiledQuery Members

[image] [image]

.NET Framework Class Library
CompiledQuery Members
CompiledQuery Class Methods See Also

Methods

Name | Description
Compile | Overloaded.

See Also

CompiledQuery Class
C1.LiveLinq Namespace


CompiledQuery Methods

[image] [image]

.NET Framework Class Library
CompiledQuery Methods
CompiledQuery Class See Also

Methods

Name | Description
Compile | Overloaded.

See Also

CompiledQuery Class
C1.LiveLinq Namespace


Compile Method

[image] [image]

.NET Framework Class Library
CompiledQuery..::.Compile Method
CompiledQuery Class See Also

Overload List

Name | Description
Compile<(Of <(T, TResult>)>)(Expression<(Of <(Func<(Of <(T, IIndexedSource<(Of <(TResult>)>)>)>)>)>)) | Compiles the query.
Compile<(Of <(T1, T2, TResult>)>)(Expression<(Of <(Func<(Of <(T1, T2, IIndexedSource<(Of <(TResult>)>)>)>)>)>)) | Compiles the query.
Compile<(Of <(T1, T2, T3, TResult>)>)(Expression<(Of <(Func<(Of <(T1, T2, T3, IIndexedSource<(Of <(TResult>)>)>)>)>)>)) | Compiles the query.
Compile<(Of <(T1, T2, T3, T4, TResult>)>)(Expression<(Of <(Func<(Of <(T1, T2, T3, T4, IIndexedSource<(Of <(TResult>)>)>)>)>)>)) | Compiles the query.

See Also

CompiledQuery Class
CompiledQuery Members
C1.LiveLinq Namespace


Compile(T, TResult) Method (Expression(Func(T, IIndexedSource(TResult))))

[image]

.NET Framework Class Library
CompiledQuery..::.Compile<(Of <(T, TResult>)>) Method (Expression<(Of <(Func<(Of <(T, IIndexedSource<(Of <(TResult>)>)>)>)>)>))
CompiledQuery Class See Also
Compiles the query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Func<T, IIndexedSource<TResult>> Compile<T, TResult>(
    Expression<Func<T, IIndexedSource<TResult>>> query
)
Visual Basic (Declaration)
Public Shared Function Compile(Of T, TResult) ( _
    query As Expression(Of Func(Of T, IIndexedSource(Of TResult))) _
) As Func(Of T, IIndexedSource(Of TResult))

Parameters

query
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, IIndexedSource <(Of <(TResult>)>)>)>)>)>)
The query expression to be compiled.

Type Parameters

T
The type of the parameter that has to be passed in when executing the delegate returned by the Compile method.
TResult
The type of TResult in the IIndexedSource<TResult> returned when executing the delegate returned by the Compile method.

Return Value

The delegate to be called to execute the compiled query with particular parameter values.

See Also

CompiledQuery Class
Compile Overload
C1.LiveLinq Namespace


Compile(T1, T2, TResult) Method (Expression(Func(T1, T2, IIndexedSource(TResult))))

[image]

.NET Framework Class Library
CompiledQuery..::.Compile<(Of <(T1, T2, TResult>)>) Method (Expression<(Of <(Func<(Of <(T1, T2, IIndexedSource<(Of <(TResult>)>)>)>)>)>))
CompiledQuery Class See Also
Compiles the query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Func<T1, T2, IIndexedSource<TResult>> Compile<T1, T2, TResult>(
    Expression<Func<T1, T2, IIndexedSource<TResult>>> query
)
Visual Basic (Declaration)
Public Shared Function Compile(Of T1, T2, TResult) ( _
    query As Expression(Of Func(Of T1, T2, IIndexedSource(Of TResult))) _
) As Func(Of T1, T2, IIndexedSource(Of TResult))

Parameters

query
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T1, T2, IIndexedSource <(Of <(TResult>)>)>)>)>)>)
The query expression to be compiled.

Type Parameters

T1
The type of the first parameter that has to be passed in when executing the delegate returned by the Compile method.
T2
The type of the second parameter that has to be passed in when executing the delegate returned by the Compile method.
TResult
The type of TResult in the IIndexedSource<TResult> returned when executing the delegate returned by the Compile method.

Return Value

The delegate to be called to execute the compiled query with particular parameter values.

See Also

CompiledQuery Class
Compile Overload
C1.LiveLinq Namespace


Compile(T1, T2, T3, TResult) Method (Expression(Func(T1, T2, T3, IIndexedSource(TResult))))

[image]

.NET Framework Class Library
CompiledQuery..::.Compile<(Of <(T1, T2, T3, TResult>)>) Method (Expression<(Of <(Func<(Of <(T1, T2, T3, IIndexedSource<(Of <(TResult>)>)>)>)>)>))
CompiledQuery Class See Also
Compiles the query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Func<T1, T2, T3, IIndexedSource<TResult>> Compile<T1, T2, T3, TResult>(
    Expression<Func<T1, T2, T3, IIndexedSource<TResult>>> query
)
Visual Basic (Declaration)
Public Shared Function Compile(Of T1, T2, T3, TResult) ( _
    query As Expression(Of Func(Of T1, T2, T3, IIndexedSource(Of TResult))) _
) As Func(Of T1, T2, T3, IIndexedSource(Of TResult))

Parameters

query
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T1, T2, T3, IIndexedSource <(Of <(TResult>)>)>)>)>)>)
The query expression to be compiled.

Type Parameters

T1
The type of the first parameter that has to be passed in when executing the delegate returned by the Compile method.
T2
The type of the second parameter that has to be passed in when executing the delegate returned by the Compile method.
T3
The type of the third parameter that has to be passed in when executing the delegate returned by the Compile method.
TResult
The type of TResult in the IIndexedSource<TResult> returned when executing the delegate returned by the Compile method.

Return Value

The delegate to be called to execute the compiled query with particular parameter values.

See Also

CompiledQuery Class
Compile Overload
C1.LiveLinq Namespace


Compile(T1, T2, T3, T4, TResult) Method (Expression(Func(T1, T2, T3, T4, IIndexedSource(TResult))))

[image]

.NET Framework Class Library
CompiledQuery..::.Compile<(Of <(T1, T2, T3, T4, TResult>)>) Method (Expression<(Of <(Func<(Of <(T1, T2, T3, T4, IIndexedSource<(Of <(TResult>)>)>)>)>)>))
CompiledQuery Class See Also
Compiles the query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Func<T1, T2, T3, T4, IIndexedSource<TResult>> Compile<T1, T2, T3, T4, TResult>(
    Expression<Func<T1, T2, T3, T4, IIndexedSource<TResult>>> query
)
Visual Basic (Declaration)
Public Shared Function Compile(Of T1, T2, T3, T4, TResult) ( _
    query As Expression(Of Func(Of T1, T2, T3, T4, IIndexedSource(Of TResult))) _
) As Func(Of T1, T2, T3, T4, IIndexedSource(Of TResult))

Parameters

query
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T1, T2, T3, T4, IIndexedSource <(Of <(TResult>)>)>)>)>)>)
The query expression to be compiled.

Type Parameters

T1
The type of the first parameter that has to be passed in when executing the delegate returned by the Compile method.
T2
The type of the second parameter that has to be passed in when executing the delegate returned by the Compile method.
T3
The type of the third parameter that has to be passed in when executing the delegate returned by the Compile method.
T4
The type of the fourth parameter that has to be passed in when executing the delegate returned by the Compile method.
TResult
The type of TResult in the IIndexedSource<TResult> returned when executing the delegate returned by the Compile method.

Return Value

The delegate to be called to execute the compiled query with particular parameter values.

See Also

CompiledQuery Class
Compile Overload
C1.LiveLinq Namespace


DeletedStateIsAvailableAttribute Class

[image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute Class
Members See Also
Indicates that the properties of an object of a class still return correct property values after the object has been deleted from the collection it belonged to.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public sealed class DeletedStateIsAvailableAttribute : Attribute
Visual Basic (Declaration)
Public NotInheritable Class DeletedStateIsAvailableAttribute _
    Inherits Attribute

Remarks

This attribute is used with classes of elements of IndexedCollection<(Of <(T>)>) and other collections implementing IObservableSource<(Of <(T>)>). It gives you a way of changing the value of IsDeletedStateAvailable without having to create a full-blown custom implementation of the IObservableSource<(Of <(T>)>) interface.

Inheritance Hierarchy

System..::.Object
System..::.Attribute
C1.LiveLinq..::.DeletedStateIsAvailableAttribute

See Also

DeletedStateIsAvailableAttribute Members
C1.LiveLinq Namespace


DeletedStateIsAvailableAttribute Members

[image] [image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute Members
DeletedStateIsAvailableAttribute Class Constructors Methods Properties See Also

The DeletedStateIsAvailableAttribute type exposes the following members.

Constructors

Name | Description
DeletedStateIsAvailableAttribute | Initializes a new instance of the DeletedStateIsAvailableAttribute class.

Methods

Name | Description
Equals | Returns a value that indicates whether this instance is equal to a specified object. (Inherited from Attribute.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Returns the hash code for this instance. (Inherited from Attribute.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
IsDefaultAttribute | When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class. (Inherited from Attribute.)
Match | When overridden in a derived class, returns a value that indicates whether this instance equals a specified object. (Inherited from Attribute.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
IsAvailable | true if the properties of an object of the class still return correct property values after the object has been deleted from the collection it belonged to.
TypeId | When implemented in a derived class, gets a unique identifier for this Attribute. (Inherited from Attribute.)

See Also

DeletedStateIsAvailableAttribute Class
C1.LiveLinq Namespace


DeletedStateIsAvailableAttribute Constructor

[image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute Constructor
DeletedStateIsAvailableAttribute Class See Also
Initializes a new instance of the DeletedStateIsAvailableAttribute class.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public DeletedStateIsAvailableAttribute(
    bool isAvailable
)
Visual Basic (Declaration)
Public Sub New ( _
    isAvailable As Boolean _
)

Parameters

isAvailable
Type: System..::.Boolean
true if the properties of an object of the class still return correct property values after the object has been deleted from the collection it belonged to.

See Also

DeletedStateIsAvailableAttribute Class
C1.LiveLinq Namespace


DeletedStateIsAvailableAttribute Methods

[image] [image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute Methods
DeletedStateIsAvailableAttribute Class See Also

The DeletedStateIsAvailableAttribute type exposes the following members.

Methods

Name | Description
Equals | Returns a value that indicates whether this instance is equal to a specified object. (Inherited from Attribute.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Returns the hash code for this instance. (Inherited from Attribute.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
IsDefaultAttribute | When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class. (Inherited from Attribute.)
Match | When overridden in a derived class, returns a value that indicates whether this instance equals a specified object. (Inherited from Attribute.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

DeletedStateIsAvailableAttribute Class
C1.LiveLinq Namespace


DeletedStateIsAvailableAttribute Properties

[image] [image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute Properties
DeletedStateIsAvailableAttribute Class See Also

The DeletedStateIsAvailableAttribute type exposes the following members.

Properties

Name | Description
IsAvailable | true if the properties of an object of the class still return correct property values after the object has been deleted from the collection it belonged to.
TypeId | When implemented in a derived class, gets a unique identifier for this Attribute. (Inherited from Attribute.)

See Also

DeletedStateIsAvailableAttribute Class
C1.LiveLinq Namespace


IsAvailable Property

[image]

.NET Framework Class Library
DeletedStateIsAvailableAttribute..::.IsAvailable Property
DeletedStateIsAvailableAttribute Class See Also
true if the properties of an object of the class still return correct property values after the object has been deleted from the collection it belonged to.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool IsAvailable { get; private set; }
Visual Basic (Declaration)
Public Property IsAvailable As Boolean

See Also

DeletedStateIsAvailableAttribute Class
C1.LiveLinq Namespace


Hints Class

[image]

.NET Framework Class Library
Hints Class
Members See Also
Provides a static (extension) method used as a hint that can be applied to an expression (usually, a property) in a query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class Hints
Visual Basic (Declaration)
Public NotInheritable Class Hints

Remarks

A hint does not change the value of the expression it is applied to, it only tells LiveLinq to create and use an index on that property, if possible. See How to create indexes.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq..::.Hints

See Also

Hints Members
C1.LiveLinq Namespace


Hints Members

[image] [image]

.NET Framework Class Library
Hints Members
Hints Class Methods Properties See Also

The Hints type exposes the following members.

Methods

Name | Description
Indexed | Overloaded.

Properties

Name | Description
DefaultAction | Gets or sets the default action for indexing hints.

See Also

Hints Class
C1.LiveLinq Namespace


Hints Methods

[image] [image]

.NET Framework Class Library
Hints Methods
Hints Class See Also

Methods

Name | Description
Indexed | Overloaded.

See Also

Hints Class
C1.LiveLinq Namespace


Indexed Method

[image] [image]

.NET Framework Class Library
Hints..::.Indexed Method
Hints Class See Also

Overload List

Name | Description
Indexed<(Of <(T>)>)(T) | A hint with default action.
Indexed<(Of <(T>)>)(T, IndexingHintAction) | A hint with specified action.

See Also

Hints Class
Hints Members
C1.LiveLinq Namespace


Indexed(T) Method (T)

[image]

.NET Framework Class Library
Hints..::.Indexed<(Of <(T>)>) Method (T)
Hints Class See Also
A hint with default action.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T Indexed<T>(
    T value
)
Visual Basic (Declaration)
Public Shared Function Indexed(Of T) ( _
    value As T _
) As T

Parameters

value
Type: T
The value of the expression the hint is applied to. This value is not actually used by the hint, because the hint is never executed, its role is purely declarative.

Type Parameters

T
This can be any type, because hints are applicable to expressions of any type.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

Current default action is defined by the value of the static DefaultAction property. By default, it is IndexingHintAction.Optional.

Use the other Indexed overload if you need a hint with non-default action.

A hint does not change the value of the expression it is applied to. It only tells LiveLinq query optimizer to create and use an index on that expression, if possible. In fact, hints are removed from the expression before it is executed.

See Also: How to create indexes.

See Also

Hints Class
Indexed Overload
C1.LiveLinq Namespace


Indexed(T) Method (T, IndexingHintAction)

[image]

.NET Framework Class Library
Hints..::.Indexed<(Of <(T>)>) Method (T, IndexingHintAction)
Hints Class See Also
A hint with specified action.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T Indexed<T>(
    T value,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function Indexed(Of T) ( _
    value As T, _
    action As IndexingHintAction _
) As T

Parameters

value
Type: T
The value of the expression the hint is applied to. This value is not actually used by the hint, because the hint is never executed, its role is purely declarative.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Type Parameters

T
This can be any type, because hints are applicable to expressions of any type.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

A hint does not change the value of the expression it is applied to. It only tells LiveLinq query optimizer to create and use an index on that expression, if possible. In fact, hints are removed from the expression before it is executed.

See Also: How to create indexes.

See Also

Hints Class
Indexed Overload
C1.LiveLinq Namespace


Hints Properties

[image] [image]

.NET Framework Class Library
Hints Properties
Hints Class See Also

The Hints type exposes the following members.

Properties

Name | Description
DefaultAction | Gets or sets the default action for indexing hints.

See Also

Hints Class
C1.LiveLinq Namespace


DefaultAction Property

[image]

.NET Framework Class Library
Hints..::.DefaultAction Property
Hints Class See Also
Gets or sets the default action for indexing hints.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexingHintAction DefaultAction { get; set; }
Visual Basic (Declaration)
Public Shared Property DefaultAction As IndexingHintAction

Remarks

The default is IndexingHintAction.Optional. This setting is global for the application. If you want to change it, do it at application startup.

See Also

Hints Class
C1.LiveLinq Namespace


IndexedQueryExtensions Class

[image]

.NET Framework Class Library
IndexedQueryExtensions Class
Members See Also
Provides a set of static (extension) methods for querying objects that implement IIndexedSource<(Of <(T>)>).

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class IndexedQueryExtensions
Visual Basic (Declaration)
Public NotInheritable Class IndexedQueryExtensions

Remarks

The methods in this class provide an implementation of the LINQ query operators for querying data sources that implement IIndexedSource<(Of <(T>)>). Those data sources include LiveLinq to Objects, LiveLinq to DataSet and LiveLinq to XML, see How to query collections with LiveLinq.

These implementations of query operators use indexing and other optimization techniques to speed up query execution.

Not all standard LINQ query operators are present here, but it does not mean that they cannot be used in the same query. For the operators that are not present here, standard LINQ implementations are used, because they don't require or don't allow optimization.

Note: Live views are also LiveLinq data sources, but they have their own implementations of query operators defined in the View<(Of <(T>)>) class. Live view implementations are heavier, require more resources, so it is not recommended to use live view implementations in cases where you don't need live view functionality (for example, for querying read-only collections), see Live View Performance. If you have a live view, but want to query it using operators from IndexedQueryExtensions instead of View<(Of <(T>)>), use AsIndexed<(Of <(T>)>)(IIndexedSource<(Of <(T>)>)) to "downgrade" the live view to an IIndexedSource<(Of <(T>)>).

Inheritance Hierarchy

System..::.Object
C1.LiveLinq..::.IndexedQueryExtensions

See Also

IndexedQueryExtensions Members
C1.LiveLinq Namespace


IndexedQueryExtensions Members

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions Members
IndexedQueryExtensions Class Methods See Also

The IndexedQueryExtensions type exposes the following members.

Methods

Name | Description
AsIndexed<(Of <(T>)>) | Returns the input typed as IIndexedSource<(Of <(T>)>).
GroupBy | Overloaded.
GroupJoin<(Of <(TOuter, TInner, TKey, TResult>)>) | Correlates the elements of two collections based on equality of keys and groups the results.
Join | Overloaded.
OrderBy<(Of <(T, TKey>)>) | Sorts the elements of a collection in ascending order.
OrderByDescending<(Of <(T, TKey>)>) | Sorts the elements of a collection in descending order.
Select<(Of <(TSource, TResult>)>) | Projects each element of a collection into a new form.
SelectMany | Overloaded.
ToIndexed | Overloaded.
Where | Overloaded.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


IndexedQueryExtensions Methods

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions Methods
IndexedQueryExtensions Class See Also

The IndexedQueryExtensions type exposes the following members.

Methods

Name | Description
AsIndexed<(Of <(T>)>) | Returns the input typed as IIndexedSource<(Of <(T>)>).
GroupBy | Overloaded.
GroupJoin<(Of <(TOuter, TInner, TKey, TResult>)>) | Correlates the elements of two collections based on equality of keys and groups the results.
Join | Overloaded.
OrderBy<(Of <(T, TKey>)>) | Sorts the elements of a collection in ascending order.
OrderByDescending<(Of <(T, TKey>)>) | Sorts the elements of a collection in descending order.
Select<(Of <(TSource, TResult>)>) | Projects each element of a collection into a new form.
SelectMany | Overloaded.
ToIndexed | Overloaded.
Where | Overloaded.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


AsIndexed(T) Method

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.AsIndexed<(Of <(T>)>) Method
IndexedQueryExtensions Class See Also
Returns the input typed as IIndexedSource<(Of <(T>)>).

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<T> AsIndexed<T>(
    IIndexedSource<T> source
)
Visual Basic (Declaration)
Public Shared Function AsIndexed(Of T) ( _
    source As IIndexedSource(Of T) _
) As IIndexedSource(Of T)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(T>)>)
The collection to type as IIndexedSource<(Of <(T>)>).

Type Parameters

T
The type of the elements of source.

Return Value

The input collection typed as IIndexedSource<(Of <(T>)>).

Remarks

This method has no effect other than to change the compile-time type of source from a type that implements IIndexedSource<(Of <(T>)>) to IIndexedSource<(Of <(T>)>) itself. It is used to choose between query implementations when a collection implements IIndexedSource<(Of <(T>)>) but also has a different set of public query methods available.

The main scenario is when you want to perform queries on live views without creating new live views.

Live views have their own implementations of query operators defined in the View<(Of <(T>)>) class. Live view implementations are heavier, require more resources, so it is not recommended to use live view implementations in cases where you don't need live view functionality (for example, for querying read-only collections), see Live View Performance. If you have a live view, but want to query it using operators from IndexedQueryExtensions instead of View<(Of <(T>)>), use this method to "downgrade" the live view to an IIndexedSource<(Of <(T>)>). This method does not cause the live view to lose its "live" functionality, it simply returns the live view's implementation of the IIndexedSource<(Of <(T>)>) interface.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


GroupBy Method

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupBy Method
IndexedQueryExtensions Class See Also

Overload List

Name | Description
GroupBy<(Of <(TSource, TKey>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>)) | Groups the elements of a collection according to a specified key selector function.
GroupBy<(Of <(TSource, TKey, TElement>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TElement>)>)>)>)) | Groups the elements of a collection according to a specified key selector function and projects the elements for each group by using a specified function.
GroupBy<(Of <(TSource, TKey, TResult>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TKey, IEnumerable<(Of <(TSource>)>), TResult>)>)>)>)) | Groups the elements of a collection according to a specified key selector function and creates a result value from each group and its key.
GroupBy<(Of <(TSource, TKey, TElement, TResult>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TElement>)>)>)>), Expression<(Of <(Func<(Of <(TKey, IEnumerable<(Of <(TElement>)>), TResult>)>)>)>)) | Groups the elements of a collection according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.

See Also

IndexedQueryExtensions Class
IndexedQueryExtensions Members
C1.LiveLinq Namespace


GroupBy(TSource, TKey) Method (IIndexedSource(TSource), Expression(Func(TSource, TKey)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupBy<(Of <(TSource, TKey>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>))
IndexedQueryExtensions Class See Also
Groups the elements of a collection according to a specified key selector function.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, TKey>> keySelector
)
Visual Basic (Declaration)
Public Shared Function GroupBy(Of TSource, TKey) ( _
    source As IIndexedSource(Of TSource), _
    keySelector As Expression(Of Func(Of TSource, TKey)) _
) As IIndexedSource(Of IGrouping(Of TKey, TSource))

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
An IIndexedSource<(Of <(T>)>) whose elements to group
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TKey>)>)>)>)
A function to extract the key for each element.

Type Parameters

TSource
The type of the elements of source.
TKey
The type of the key returned by keySelector.

Return Value

A collection of IGrouping<(Of <(TKey, TElement>)>) objects each containing a sequence of objects and a key.

See Also

IndexedQueryExtensions Class
GroupBy Overload
C1.LiveLinq Namespace


GroupBy(TSource, TKey, TElement) Method (IIndexedSource(TSource), Expression(Func(TSource, TKey)), Expression(Func(TSource, TElement)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupBy<(Of <(TSource, TKey, TElement>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TElement>)>)>)>))
IndexedQueryExtensions Class See Also
Groups the elements of a collection according to a specified key selector function and projects the elements for each group by using a specified function.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, TKey>> keySelector,
    Expression<Func<TSource, TElement>> elementSelector
)
Visual Basic (Declaration)
Public Shared Function GroupBy(Of TSource, TKey, TElement) ( _
    source As IIndexedSource(Of TSource), _
    keySelector As Expression(Of Func(Of TSource, TKey)), _
    elementSelector As Expression(Of Func(Of TSource, TElement)) _
) As IIndexedSource(Of IGrouping(Of TKey, TElement))

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
An IIndexedSource<(Of <(T>)>) whose elements to group
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TKey>)>)>)>)
A function to extract the key for each element.
elementSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TElement>)>)>)>)
A function to map each source element to an element in the IGrouping<(Of <(TKey, TElement>)>).

Type Parameters

TSource
The type of the elements of source.
TKey
The type of the key returned by keySelector.
TElement
The type of the elements in the IGrouping<(Of <(TKey, TElement>)>).

Return Value

A collection of IGrouping<(Of <(TKey, TElement>)>) objects each containing a collection of objects of type TElement and a key.

See Also

IndexedQueryExtensions Class
GroupBy Overload
C1.LiveLinq Namespace


GroupBy(TSource, TKey, TResult) Method (IIndexedSource(TSource), Expression(Func(TSource, TKey)), Expression(Func(TKey, IEnumerable(TSource), TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupBy<(Of <(TSource, TKey, TResult>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TKey, IEnumerable<(Of <(TSource>)>), TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Groups the elements of a collection according to a specified key selector function and creates a result value from each group and its key.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> GroupBy<TSource, TKey, TResult>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, TKey>> keySelector,
    Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function GroupBy(Of TSource, TKey, TResult) ( _
    source As IIndexedSource(Of TSource), _
    keySelector As Expression(Of Func(Of TSource, TKey)), _
    resultSelector As Expression(Of Func(Of TKey, IEnumerable(Of TSource), TResult)) _
) As IIndexedSource(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
An IIndexedSource<(Of <(T>)>) whose elements to group
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TKey>)>)>)>)
A function to extract the key for each element.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TKey, IEnumerable <(Of <(TSource>)>), TResult>)>)>)>)
A function to create a result value from each group.

Type Parameters

TSource
The type of the elements of source.
TKey
The type of the key returned by keySelector.
TResult
The type of the result value returned by resultSelector

Return Value

A collection of elements of type TResult where each element represents a projection over a group and its key.

See Also

IndexedQueryExtensions Class
GroupBy Overload
C1.LiveLinq Namespace


GroupBy(TSource, TKey, TElement, TResult) Method (IIndexedSource(TSource), Expression(Func(TSource, TKey)), Expression(Func(TSource, TElement)), Expression(Func(TKey, IEnumerable(TElement), TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupBy<(Of <(TSource, TKey, TElement, TResult>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TElement>)>)>)>), Expression<(Of <(Func<(Of <(TKey, IEnumerable<(Of <(TElement>)>), TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Groups the elements of a collection according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> GroupBy<TSource, TKey, TElement, TResult>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, TKey>> keySelector,
    Expression<Func<TSource, TElement>> elementSelector,
    Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function GroupBy(Of TSource, TKey, TElement, TResult) ( _
    source As IIndexedSource(Of TSource), _
    keySelector As Expression(Of Func(Of TSource, TKey)), _
    elementSelector As Expression(Of Func(Of TSource, TElement)), _
    resultSelector As Expression(Of Func(Of TKey, IEnumerable(Of TElement), TResult)) _
) As IIndexedSource(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
An IIndexedSource<(Of <(T>)>) whose elements to group
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TKey>)>)>)>)
A function to extract the key for each element.
elementSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TElement>)>)>)>)
A function to map each source element to an element in the IGrouping<(Of <(TKey, TElement>)>).
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TKey, IEnumerable <(Of <(TElement>)>), TResult>)>)>)>)
A function to create a result value from each group.

Type Parameters

TSource
The type of the elements of source.
TKey
The type of the key returned by keySelector.
TElement
The type of the elements in the IGrouping<(Of <(TKey, TElement>)>).
TResult
The type of the result value returned by resultSelector

Return Value

A collection of elements of type TResult where each element represents a projection over a group and its key.

See Also

IndexedQueryExtensions Class
GroupBy Overload
C1.LiveLinq Namespace


GroupJoin(TOuter, TInner, TKey, TResult) Method

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.GroupJoin<(Of <(TOuter, TInner, TKey, TResult>)>) Method
IndexedQueryExtensions Class See Also
Correlates the elements of two collections based on equality of keys and groups the results.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
    IIndexedSource<TOuter> outer,
    IEnumerable<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function GroupJoin(Of TOuter, TInner, TKey, TResult) ( _
    outer As IIndexedSource(Of TOuter), _
    inner As IEnumerable(Of TInner), _
    outerKeySelector As Expression(Of Func(Of TOuter, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of TOuter, IEnumerable(Of TInner), TResult)) _
) As IIndexedSource(Of TResult)

Parameters

outer
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TOuter>)>)
The first collection to join.
inner
Type: System.Collections.Generic..::.IEnumerable <(Of <(TInner>)>)
The collection to join to the first collection.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TKey>)>)>)>)
A function to extract the join key from each element of the first collection.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, IEnumerable <(Of <(TInner>)>), TResult>)>)>)>)
A function to create a result element from an element from the first collection and a collection of matching elements from the second collection.

Type Parameters

TOuter
The type of the elements of the first collection.
TInner
The type of the elements of the second collection.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

An IIndexedSource<TResult> that contains elements of type TResult that are obtained by performing a grouped join on two collections.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


Join Method

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions..::.Join Method
IndexedQueryExtensions Class See Also

Overload List

Name | Description
Join<(Of <(TOuter, TInner, TKey, TResult>)>)(IIndexedSource<(Of <(TOuter>)>), IIndexedSource<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>)) | Correlates the elements of two collections based on matching keys.
Join<(Of <(TOuter, TInner, TKey, TResult>)>)(IIndexedSource<(Of <(TOuter>)>), IEnumerable<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>)) | Correlates the elements of two collections based on matching keys.
Join<(Of <(TOuter, TInner, TKey, TResult>)>)(IEnumerable<(Of <(TOuter>)>), IIndexedSource<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>)) | Correlates the elements of two collections based on matching keys.

See Also

IndexedQueryExtensions Class
IndexedQueryExtensions Members
C1.LiveLinq Namespace


Join(TOuter, TInner, TKey, TResult) Method (IIndexedSource(TOuter), IIndexedSource(TInner), Expression(Func(TOuter, TKey)), Expression(Func(TInner, TKey)), Expression(Func(TOuter, TInner, TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Join<(Of <(TOuter, TInner, TKey, TResult>)>) Method (IIndexedSource<(Of <(TOuter>)>), IIndexedSource<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Correlates the elements of two collections based on matching keys.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> Join<TOuter, TInner, TKey, TResult>(
    IIndexedSource<TOuter> outer,
    IIndexedSource<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, TInner, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function Join(Of TOuter, TInner, TKey, TResult) ( _
    outer As IIndexedSource(Of TOuter), _
    inner As IIndexedSource(Of TInner), _
    outerKeySelector As Expression(Of Func(Of TOuter, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of TOuter, TInner, TResult)) _
) As IIndexedSource(Of TResult)

Parameters

outer
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TOuter>)>)
The first collection to join.
inner
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TInner>)>)
The second collection to join.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TKey>)>)>)>)
A function to extract the join key from each element of the first collection.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TInner, TResult>)>)>)>)
A function to create a result element from two matching elements.

Type Parameters

TOuter
The type of the elements of the first collection.
TInner
The type of the elements of the second collection.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

An IIndexedSource<TResult> that has elements of type TResult that are obtained by performing an inner join on two collections.

See Also

IndexedQueryExtensions Class
Join Overload
C1.LiveLinq Namespace


Join(TOuter, TInner, TKey, TResult) Method (IIndexedSource(TOuter), IEnumerable(TInner), Expression(Func(TOuter, TKey)), Expression(Func(TInner, TKey)), Expression(Func(TOuter, TInner, TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Join<(Of <(TOuter, TInner, TKey, TResult>)>) Method (IIndexedSource<(Of <(TOuter>)>), IEnumerable<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Correlates the elements of two collections based on matching keys.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> Join<TOuter, TInner, TKey, TResult>(
    IIndexedSource<TOuter> outer,
    IEnumerable<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, TInner, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function Join(Of TOuter, TInner, TKey, TResult) ( _
    outer As IIndexedSource(Of TOuter), _
    inner As IEnumerable(Of TInner), _
    outerKeySelector As Expression(Of Func(Of TOuter, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of TOuter, TInner, TResult)) _
) As IIndexedSource(Of TResult)

Parameters

outer
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TOuter>)>)
The first collection to join.
inner
Type: System.Collections.Generic..::.IEnumerable <(Of <(TInner>)>)
The second collection to join.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TKey>)>)>)>)
A function to extract the join key from each element of the first collection.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TInner, TResult>)>)>)>)
A function to create a result element from two matching elements.

Type Parameters

TOuter
The type of the elements of the first collection.
TInner
The type of the elements of the second collection.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

An IIndexedSource<TResult> that has elements of type TResult that are obtained by performing an inner join on two collections.

See Also

IndexedQueryExtensions Class
Join Overload
C1.LiveLinq Namespace


Join(TOuter, TInner, TKey, TResult) Method (IEnumerable(TOuter), IIndexedSource(TInner), Expression(Func(TOuter, TKey)), Expression(Func(TInner, TKey)), Expression(Func(TOuter, TInner, TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Join<(Of <(TOuter, TInner, TKey, TResult>)>) Method (IEnumerable<(Of <(TOuter>)>), IIndexedSource<(Of <(TInner>)>), Expression<(Of <(Func<(Of <(TOuter, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TInner, TKey>)>)>)>), Expression<(Of <(Func<(Of <(TOuter, TInner, TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Correlates the elements of two collections based on matching keys.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> Join<TOuter, TInner, TKey, TResult>(
    IEnumerable<TOuter> outer,
    IIndexedSource<TInner> inner,
    Expression<Func<TOuter, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<TOuter, TInner, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function Join(Of TOuter, TInner, TKey, TResult) ( _
    outer As IEnumerable(Of TOuter), _
    inner As IIndexedSource(Of TInner), _
    outerKeySelector As Expression(Of Func(Of TOuter, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of TOuter, TInner, TResult)) _
) As IIndexedSource(Of TResult)

Parameters

outer
Type: System.Collections.Generic..::.IEnumerable <(Of <(TOuter>)>)
The first collection to join.
inner
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TInner>)>)
The second collection to join.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TKey>)>)>)>)
A function to extract the join key from each element of the first collection.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TOuter, TInner, TResult>)>)>)>)
A function to create a result element from two matching elements.

Type Parameters

TOuter
The type of the elements of the first collection.
TInner
The type of the elements of the second collection.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

An IIndexedSource<TResult> that has elements of type TResult that are obtained by performing an inner join on two collections.

See Also

IndexedQueryExtensions Class
Join Overload
C1.LiveLinq Namespace


OrderBy(T, TKey) Method

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.OrderBy<(Of <(T, TKey>)>) Method
IndexedQueryExtensions Class See Also
Sorts the elements of a collection in ascending order.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Ordering<T> OrderBy<T, TKey>(
    IIndexedSource<T> source,
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Shared Function OrderBy(Of T, TKey) ( _
    source As IIndexedSource(Of T), _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Ordering(Of T)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(T>)>)
A collection of values to order.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, TKey>)>)>)>)
A function to extract a key from an element.

Type Parameters

T
The type of the elements of source.
TKey
The type of the key returned by keySelector.

Return Value

An IIndexedSource<(Of <(T>)>) whose elements are sorted according to a key.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


OrderByDescending(T, TKey) Method

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.OrderByDescending<(Of <(T, TKey>)>) Method
IndexedQueryExtensions Class See Also
Sorts the elements of a collection in descending order.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static Ordering<T> OrderByDescending<T, TKey>(
    IIndexedSource<T> source,
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Shared Function OrderByDescending(Of T, TKey) ( _
    source As IIndexedSource(Of T), _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Ordering(Of T)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(T>)>)
A collection of values to order.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, TKey>)>)>)>)
A function to extract a key from an element.

Type Parameters

T
The type of the elements of source.
TKey
The type of the key returned by keySelector.

Return Value

An IIndexedSource<(Of <(T>)>) whose elements are sorted in descending order according to a key.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


Select(TSource, TResult) Method

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Select<(Of <(TSource, TResult>)>) Method
IndexedQueryExtensions Class See Also
Projects each element of a collection into a new form.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> Select<TSource, TResult>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, TResult>> selector
)
Visual Basic (Declaration)
Public Shared Function Select(Of TSource, TResult) ( _
    source As IIndexedSource(Of TSource), _
    selector As Expression(Of Func(Of TSource, TResult)) _
) As IIndexedSource(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
An IIndexedSource<TSource> collection of values to invoke a transform function on.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TResult>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.
TResult
The type of the value returned by selector.

Return Value

An IIndexedSource<TResult> whose elements are the result of invoking the transform function on each element of source.

See Also

IndexedQueryExtensions Class
C1.LiveLinq Namespace


SelectMany Method

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions..::.SelectMany Method
IndexedQueryExtensions Class See Also

Overload List

Name | Description
SelectMany<(Of <(TSource, TResult>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, IEnumerable<(Of <(TResult>)>)>)>)>)>)) | Projects each element of a collection to a sequence of collections and flattens the resulting collections into one collection.
SelectMany<(Of <(TSource, TCollection, TResult>)>)(IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, IEnumerable<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TCollection, TResult>)>)>)>)) | Projects each element of a collection to a sequence of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein.

See Also

IndexedQueryExtensions Class
IndexedQueryExtensions Members
C1.LiveLinq Namespace


SelectMany(TSource, TResult) Method (IIndexedSource(TSource), Expression(Func(TSource, IEnumerable(TResult))))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.SelectMany<(Of <(TSource, TResult>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, IEnumerable<(Of <(TResult>)>)>)>)>)>))
IndexedQueryExtensions Class See Also
Projects each element of a collection to a sequence of collections and flattens the resulting collections into one collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> SelectMany<TSource, TResult>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, IEnumerable<TResult>>> selector
)
Visual Basic (Declaration)
Public Shared Function SelectMany(Of TSource, TResult) ( _
    source As IIndexedSource(Of TSource), _
    selector As Expression(Of Func(Of TSource, IEnumerable(Of TResult))) _
) As IIndexedSource(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
A collection of values to project.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, IEnumerable <(Of <(TResult>)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.
TResult
The type of the elements of the sequence returned by selector.

Return Value

An IIndexedSource<TResult> whose elements are the result of invoking the one-to-many transform function on each element of the source collection.

See Also

IndexedQueryExtensions Class
SelectMany Overload
C1.LiveLinq Namespace


SelectMany(TSource, TCollection, TResult) Method (IIndexedSource(TSource), Expression(Func(TSource, IEnumerable(TCollection))), Expression(Func(TSource, TCollection, TResult)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.SelectMany<(Of <(TSource, TCollection, TResult>)>) Method (IIndexedSource<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, IEnumerable<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TCollection, TResult>)>)>)>))
IndexedQueryExtensions Class See Also
Projects each element of a collection to a sequence of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<TResult> SelectMany<TSource, TCollection, TResult>(
    IIndexedSource<TSource> source,
    Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector,
    Expression<Func<TSource, TCollection, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function SelectMany(Of TSource, TCollection, TResult) ( _
    source As IIndexedSource(Of TSource), _
    collectionSelector As Expression(Of Func(Of TSource, IEnumerable(Of TCollection))), _
    resultSelector As Expression(Of Func(Of TSource, TCollection, TResult)) _
) As IIndexedSource(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(TSource>)>)
A collection of values to project.
collectionSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, IEnumerable <(Of <(TCollection>)>)>)>)>)>)
A transform function to apply to each element of the input collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TCollection, TResult>)>)>)>)
A transform function to apply to each element of the intermediate sequence.

Type Parameters

TSource
The type of the elements of source.
TCollection
The type of the intermediate elements collected by collectionSelector.
TResult
The type of the elements of the resulting collection.

Return Value

An IIndexedSource<TResult> whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

See Also

IndexedQueryExtensions Class
SelectMany Overload
C1.LiveLinq Namespace


ToIndexed Method

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions..::.ToIndexed Method
IndexedQueryExtensions Class See Also

Overload List

Name | Description
ToIndexed<(Of <(T>)>)(IObservableSource<(Of <(T>)>)) | Creates an IIndexedSource<(Of <(T>)>) based on the specified IObservableSource<(Of <(T>)>) collection.
ToIndexed<(Of <(T>)>)(BindingList<(Of <(T>)>)) | A typed specialization of the ToIndexed<(Of <(T>)>)(IBindingList) method.
ToIndexed<(Of <(T>)>)(IBindingList) | Creates an IndexedCollection<(Of <(T>)>) based on the specified IBindingList data source.

See Also

IndexedQueryExtensions Class
IndexedQueryExtensions Members
C1.LiveLinq Namespace


ToIndexed(T) Method (IObservableSource(T))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.ToIndexed<(Of <(T>)>) Method (IObservableSource<(Of <(T>)>))
IndexedQueryExtensions Class See Also
Creates an IIndexedSource<(Of <(T>)>) based on the specified IObservableSource<(Of <(T>)>) collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<T> ToIndexed<T>(
    IObservableSource<T> source
)
Visual Basic (Declaration)
Public Shared Function ToIndexed(Of T) ( _
    source As IObservableSource(Of T) _
) As IIndexedSource(Of T)

Parameters

source
Type: C1.LiveLinq..::.IObservableSource <(Of <(T>)>)
An IObservableSource<(Of <(T>)>) collection to base an IIndexedSource<(Of <(T>)>) on.

Type Parameters

T
The type of the elements in the collection.

Return Value

An IIndexedSource<(Of <(T>)>) that contains the same elements as the IObservableSource<(Of <(T>)>) collection and enables indexing of that collection.

Remarks

Use this method to index and query your collection if that collection is your own custom implementation of the IObservableSource<(Of <(T>)>) interface.

Elements of the source collection aren't duplicated or copied to a new collection. This method just wraps the original collection in an IIndexedSource<(Of <(T>)>), enabling its indexing by using the change notification mechanism of IObservableSource<(Of <(T>)>).

Note: Indexes created on the resulting IIndexedSource<(Of <(T>)>) are owned by it and not by the original collection. Every ToIndexed() call creates a separate object that has its own separate indexes. Avoid calling ToIndexed() repeatedly for the same collection because it can increase the cost of maintaining indexes.

See Also

IndexedQueryExtensions Class
ToIndexed Overload
C1.LiveLinq Namespace


ToIndexed(T) Method (BindingList(T))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.ToIndexed<(Of <(T>)>) Method (BindingList<(Of <(T>)>))
IndexedQueryExtensions Class See Also
A typed specialization of the ToIndexed<(Of <(T>)>)(IBindingList) method.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedCollection<T> ToIndexed<T>(
    BindingList<T> source
)
Visual Basic (Declaration)
Public Shared Function ToIndexed(Of T) ( _
    source As BindingList(Of T) _
) As IndexedCollection(Of T)

Parameters

source
Type: System.ComponentModel..::.BindingList <(Of <(T>)>)
A BindingList<(Of <(T>)>) data source to represent as an IndexedCollection<(Of <(T>)>).

Type Parameters

T
The type of the elements in the collection.

Return Value

An IIndexedSource<(Of <(T>)>) that contains the same elements as the BindingList<(Of <(T>)>) and enables indexing of that data source.

See Also

IndexedQueryExtensions Class
ToIndexed Overload
C1.LiveLinq Namespace


ToIndexed(T) Method (IBindingList)

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.ToIndexed<(Of <(T>)>) Method (IBindingList)
IndexedQueryExtensions Class See Also
Creates an IndexedCollection<(Of <(T>)>) based on the specified IBindingList data source.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedCollection<T> ToIndexed<T>(
    IBindingList source
)
Visual Basic (Declaration)
Public Shared Function ToIndexed(Of T) ( _
    source As IBindingList _
) As IndexedCollection(Of T)

Parameters

source
Type: System.ComponentModel..::.IBindingList
An IBindingList data source to represent as an IndexedCollection<(Of <(T>)>).

Type Parameters

T
The type of the elements in the collection.

Return Value

An IndexedCollection<(Of <(T>)>) that contains the same elements as the IBindingList and enables indexing of that data source.

Remarks

Use this method to index and query your existing data sources. The only requirements for the data source is that it implements the standard data binding interface IBindingList.

Note: Indexes created on the resulting IndexedCollection<(Of <(T>)>) are owned by it and not by the original data source. Every ToIndexed() call creates a separate object that has its own separate indexes. Avoid calling ToIndexed() repeatedly for the same collection because it can increase the cost of maintaining indexes.

See Also

IndexedQueryExtensions Class
ToIndexed Overload
C1.LiveLinq Namespace


Where Method

[image] [image]

.NET Framework Class Library
IndexedQueryExtensions..::.Where Method
IndexedQueryExtensions Class See Also

Overload List

Name | Description
Where<(Of <(T>)>)(IIndexedSource<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>)) | Filters the source collection based on a predicate.
Where<(Of <(T>)>)(IIndexedSource<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>), Boolean) | Filters the source collection based on a predicate, preserving the order of the source collection.

See Also

IndexedQueryExtensions Class
IndexedQueryExtensions Members
C1.LiveLinq Namespace


Where(T) Method (IIndexedSource(T), Expression(Func(T, Boolean)))

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Where<(Of <(T>)>) Method (IIndexedSource<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>))
IndexedQueryExtensions Class See Also
Filters the source collection based on a predicate.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<T> Where<T>(
    IIndexedSource<T> source,
    Expression<Func<T, bool>> predicate
)
Visual Basic (Declaration)
Public Shared Function Where(Of T) ( _
    source As IIndexedSource(Of T), _
    predicate As Expression(Of Func(Of T, Boolean)) _
) As IIndexedSource(Of T)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(T>)>)
An IIndexedSource<(Of <(T>)>) to filter.
predicate
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, Boolean >)>)>)>)
A function to test each element for a condition.

Type Parameters

T
The type of the elements of source.

Return Value

An IIndexedSource<(Of <(T>)>) that contains elements from the input collection that satisfy the condition.

Remarks

If an index is used to optimized performance of this operation, the resulting collection may not be in the same order as the source collection. If you need to preserve the order, use the other overload of the Where operator. It will still be optimized, albeit to a lesser degree.

See Also

IndexedQueryExtensions Class
Where Overload
C1.LiveLinq Namespace


Where(T) Method (IIndexedSource(T), Expression(Func(T, Boolean)), Boolean)

[image]

.NET Framework Class Library
IndexedQueryExtensions..::.Where<(Of <(T>)>) Method (IIndexedSource<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>), Boolean)
IndexedQueryExtensions Class See Also
Filters the source collection based on a predicate, preserving the order of the source collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IIndexedSource<T> Where<T>(
    IIndexedSource<T> source,
    Expression<Func<T, bool>> predicate,
    bool preserveOriginalOrder
)
Visual Basic (Declaration)
Public Shared Function Where(Of T) ( _
    source As IIndexedSource(Of T), _
    predicate As Expression(Of Func(Of T, Boolean)), _
    preserveOriginalOrder As Boolean _
) As IIndexedSource(Of T)

Parameters

source
Type: C1.LiveLinq.Indexing..::.IIndexedSource <(Of <(T>)>)
An IIndexedSource<(Of <(T>)>) to filter.
predicate
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, Boolean >)>)>)>)
A function to test each element for a condition.
preserveOriginalOrder
Type: System..::.Boolean
Specifies whether the source order must be preserved in the result.

Type Parameters

T
The type of the elements of source.

Return Value

An IIndexedSource<(Of <(T>)>) that contains elements from the input collection that satisfy the condition.

Remarks

Preserving the order can lessen the effect of performance optimization using an index. Use this overload only if preserving the order in this operation is essential.

See Also

IndexedQueryExtensions Class
Where Overload
C1.LiveLinq Namespace


IndexingHintAction Enumeration

[image]

.NET Framework Class Library
IndexingHintAction Enumeration
See Also
Specifies the actions taken by LiveLinq query optimizer when it encounters an Indexed() hint applied to an expression (usually, a property) in a query.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum IndexingHintAction
Visual Basic (Declaration)
Public Enumeration IndexingHintAction

Members

Member name | Description
Mandatory | Create an index for this expression, if such index does not already exist. Use this index in executing the query (perform an index scan using that index). Throw an exception if it is impossible to use it in query execution.
Optional | Create an index for this expression, if such index does not already exist. Use this index in executing the query, if it is possible. Do not throw exception if it is impossible to use that index in query execution.
UseExistingIndex | Check that there exists an index for this expression. If it does not exist, throw an exception. Use this index in executing the query. Throw an exception if it is impossible to use this index in query execution.

See Also

C1.LiveLinq Namespace


IObservableSource(T) Interface

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>) Interface
Members See Also
Provides methods and events that are required for LiveLinq functionality, indexing and live views.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public interface IObservableSource<T> : IEnumerable<T>,
    IEnumerable
Visual Basic (Declaration)
Public Interface IObservableSource(Of T) _
    Implements IEnumerable(Of T), IEnumerable

Type Parameters

T
The type of the elements in the collection.

Remarks

Indexing and live view functionality is available for any collection that supports change notifications necessary for maintaining indexes and live views, that is, fires events when an item is added to or removed from the collection and when a property of the item changes. So, the members of this interface are mostly concerned with providing such notifications.

Classes implementing this interface usually also implement IIndexedSource<(Of <(T>)>).

Both these interfaces are implemented by all main LiveLinq collection classes: IndexedCollection<(Of <(T>)>), IndexedDataTable<(Of <(TRow>)>), View<(Of <(T>)>).

You need to implement this interface only if you want to define your own indexable collection classes and then only if they don't inherit from IndexedCollection<(Of <(T>)>), see LiveLinq to Objects: IndexedCollection(T) and other collection classes.

See Also

IObservableSource<(Of <(T>)>) Members
C1.LiveLinq Namespace


IObservableSource(T) Members

[image] [image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>) Members
IObservableSource<(Of <(T>)>) Interface Methods Properties Events See Also

The IObservableSource<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
EnableItemOrdinals | After this method is called, the collection is required to provide Ordinal in event data.
GetEnumerator | Overloaded.

Properties

Name | Description
CreateNew | This delegate is used to create new items. If it is null, a public parameterless constructor of type T is used.
IsDeletedStateAvailable | Gets a value indicating whether an item of this collection can still return correct property values after it has been deleted from the collection.
SupportsChangingEvent | Gets a value that indicates whether this collection raises Changing event before one of its items changes.
SupportsItemOrdinals | Gets a value that indicates whether this collection is capable of providing the ordinal position of the changed item when it notifies of an item change.

Events

Name | Description
Changed | Occurs after an item of the collection or the entire collection has changed.
Changing | Occurs before an item of the collection or the entire collection changes.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


IObservableSource(T) Methods

[image] [image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>) Methods
IObservableSource<(Of <(T>)>) Interface See Also

The IObservableSource<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
EnableItemOrdinals | After this method is called, the collection is required to provide Ordinal in event data.
GetEnumerator | Overloaded.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


EnableItemOrdinals Method

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals Method
IObservableSource<(Of <(T>)>) Interface See Also
After this method is called, the collection is required to provide Ordinal in event data.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void EnableItemOrdinals()
Visual Basic (Declaration)
Sub EnableItemOrdinals

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


GetEnumerator Method

[image] [image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.GetEnumerator Method
IObservableSource<(Of <(T>)>) Interface See Also

Overload List

Name | Description
GetEnumerator()()() | Returns an enumerator that iterates through the collection. (Inherited from IEnumerable <(Of <(T>)>).)
GetEnumerator()()() | Returns an enumerator that iterates through a collection. (Inherited from IEnumerable.)

See Also

IObservableSource<(Of <(T>)>) Interface
IObservableSource<(Of <(T>)>) Members
C1.LiveLinq Namespace


IObservableSource(T) Properties

[image] [image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>) Properties
IObservableSource<(Of <(T>)>) Interface See Also

The IObservableSource<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
CreateNew | This delegate is used to create new items. If it is null, a public parameterless constructor of type T is used.
IsDeletedStateAvailable | Gets a value indicating whether an item of this collection can still return correct property values after it has been deleted from the collection.
SupportsChangingEvent | Gets a value that indicates whether this collection raises Changing event before one of its items changes.
SupportsItemOrdinals | Gets a value that indicates whether this collection is capable of providing the ordinal position of the changed item when it notifies of an item change.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


CreateNew Property

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.CreateNew Property
IObservableSource<(Of <(T>)>) Interface See Also
This delegate is used to create new items. If it is null, a public parameterless constructor of type T is used.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Func<T> CreateNew { get; }
Visual Basic (Declaration)
ReadOnly Property CreateNew As Func(Of T)

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


IsDeletedStateAvailable Property

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable Property
IObservableSource<(Of <(T>)>) Interface See Also
Gets a value indicating whether an item of this collection can still return correct property values after it has been deleted from the collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IsDeletedStateAvailable { get; }
Visual Basic (Declaration)
ReadOnly Property IsDeletedStateAvailable As Boolean

Return Value

true if deleted items can still be used to get property values.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace
C1.LiveLinq..::.DeletedStateIsAvailableAttribute


SupportsChangingEvent Property

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent Property
IObservableSource<(Of <(T>)>) Interface See Also
Gets a value that indicates whether this collection raises Changing event before one of its items changes.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool SupportsChangingEvent { get; }
Visual Basic (Declaration)
ReadOnly Property SupportsChangingEvent As Boolean

Remarks

Raising the Changed event is mandatory, but Changing event is optional. However, supporting Changing event is recommended, because without that event LiveLinq will need to maintain additional data in memory to compensate for its absence.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


SupportsItemOrdinals Property

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals Property
IObservableSource<(Of <(T>)>) Interface See Also
Gets a value that indicates whether this collection is capable of providing the ordinal position of the changed item when it notifies of an item change.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool SupportsItemOrdinals { get; }
Visual Basic (Declaration)
ReadOnly Property SupportsItemOrdinals As Boolean

Return Value

true if the collection can provide item ordinal positions.

Remarks

If this property returns true, LiveLinq can call the EnableItemOrdinals()()() method to require providing ordinals.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


IObservableSource(T) Events

[image] [image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>) Events
IObservableSource<(Of <(T>)>) Interface See Also

The IObservableSource<(Of <(T>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after an item of the collection or the entire collection has changed.
Changing | Occurs before an item of the collection or the entire collection changes.

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


Changed Event

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.Changed Event
IObservableSource<(Of <(T>)>) Interface See Also
Occurs after an item of the collection or the entire collection has changed.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event EventHandler<SourceChangeEventArgs<T>> Changed
Visual Basic (Declaration)
Event Changed As EventHandler(Of SourceChangeEventArgs(Of T))

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


Changing Event

[image]

.NET Framework Class Library
IObservableSource<(Of <(T>)>)..::.Changing Event
IObservableSource<(Of <(T>)>) Interface See Also
Occurs before an item of the collection or the entire collection changes.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event EventHandler<SourceChangeEventArgs<T>> Changing
Visual Basic (Declaration)
Event Changing As EventHandler(Of SourceChangeEventArgs(Of T))

See Also

IObservableSource<(Of <(T>)>) Interface
C1.LiveLinq Namespace


LiveViewExtensions Class

[image]

.NET Framework Class Library
LiveViewExtensions Class
Members See Also
Provides a set of static (extension) methods used in queries to define live views.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class LiveViewExtensions
Visual Basic (Declaration)
Public NotInheritable Class LiveViewExtensions

Inheritance Hierarchy

System..::.Object
C1.LiveLinq..::.LiveViewExtensions

See Also

LiveViewExtensions Members
C1.LiveLinq Namespace


LiveViewExtensions Members

[image] [image]

.NET Framework Class Library
LiveViewExtensions Members
LiveViewExtensions Class Methods See Also

The LiveViewExtensions type exposes the following members.

Methods

Name | Description
AsLive | Overloaded.
AsNonUpdatable<(Of <(T>)>) | Specifies a view as read-only.
AsUpdatable<(Of <(T>)>) | Specifies a view as updatable.
LiveAggregate | Overloaded.
LiveAverage | Overloaded.
LiveCount | Overloaded.
LiveMax | Overloaded.
LiveMin | Overloaded.
LiveSum | Overloaded.

See Also

LiveViewExtensions Class
C1.LiveLinq Namespace


LiveViewExtensions Methods

[image] [image]

.NET Framework Class Library
LiveViewExtensions Methods
LiveViewExtensions Class See Also

The LiveViewExtensions type exposes the following members.

Methods

Name | Description
AsLive | Overloaded.
AsNonUpdatable<(Of <(T>)>) | Specifies a view as read-only.
AsUpdatable<(Of <(T>)>) | Specifies a view as updatable.
LiveAggregate | Overloaded.
LiveAverage | Overloaded.
LiveCount | Overloaded.
LiveMax | Overloaded.
LiveMin | Overloaded.
LiveSum | Overloaded.

See Also

LiveViewExtensions Class
C1.LiveLinq Namespace


AsLive Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive Method
LiveViewExtensions Class See Also

Overload List

Name | Description
AsLive<(Of <(T>)>)(IObservableSource<(Of <(T>)>)) | Creates a view based on the specified IObservableSource<(Of <(T>)>) collection.
AsLive<(Of <(T>)>)(BindingList<(Of <(T>)>)) | A typed specialization of the AsLive<(Of <(T>)>)(IBindingList) method.
AsLive<(Of <(T>)>)(IBindingList) | Creates a view based on the specified IBindingList data source.
AsLive<(Of <(T>)>)(IObservableSource<(Of <(T>)>), ViewOrder) | Creates a view based on the specified IObservableSource<(Of <(T>)>) collection.
AsLive<(Of <(T>)>)(BindingList<(Of <(T>)>), ViewOrder) | A typed specialization of the AsLive<(Of <(T>)>)(IBindingList, ViewOrder) method.
AsLive<(Of <(T>)>)(IBindingList, ViewOrder) | Creates a view based on the specified IBindingList data source.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


AsLive(T) Method (IObservableSource(T))

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (IObservableSource<(Of <(T>)>))
LiveViewExtensions Class See Also
Creates a view based on the specified IObservableSource<(Of <(T>)>) collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    IObservableSource<T> source
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As IObservableSource(Of T) _
) As View(Of T)

Parameters

source
Type: C1.LiveLinq..::.IObservableSource <(Of <(T>)>)
The IObservableSource<(Of <(T>)>) collection to expose as a view.

Type Parameters

T
The type of the elements in the collection.

Return Value

A view that contains the same elements as the IObservableSource<(Of <(T>)>)

Remarks

The resulting view may have its elements ordered differently than they are ordered in the source collection. Correspondingly, views built on this resulting view (for example, if you filter it with Where) will not preserve the source order either. If you need to preserve the source order, consider using the other AsLive overload where you can specify to what extent you need the order to be preserved.

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsLive(T) Method (BindingList(T))

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (BindingList<(Of <(T>)>))
LiveViewExtensions Class See Also
A typed specialization of the AsLive<(Of <(T>)>)(IBindingList) method.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    BindingList<T> source
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As BindingList(Of T) _
) As View(Of T)

Parameters

source
Type: System.ComponentModel..::.BindingList <(Of <(T>)>)
The BindingList<(Of <(T>)>) data source to expose as a view.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the BindingList<(Of <(T>)>).

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsLive(T) Method (IBindingList)

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (IBindingList)
LiveViewExtensions Class See Also
Creates a view based on the specified IBindingList data source.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    IBindingList source
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As IBindingList _
) As View(Of T)

Parameters

source
Type: System.ComponentModel..::.IBindingList
The IBindingList data source to expose as a view.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the IBindingList.

Remarks

Use this method to build views from existing data sources. The only requirements for the data source is that it implements the standard data binding interface IBindingList.

The resulting view may have its elements ordered differently than they are ordered in the source collection. Correspondingly, views built on this resulting view (for example, if you filter it with Where) will not preserve the source order either. If you need to preserve the source order, consider using the other AsLive overload where you can specify to what extent you need the order to be preserved.

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsLive(T) Method (IObservableSource(T), ViewOrder)

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (IObservableSource<(Of <(T>)>), ViewOrder)
LiveViewExtensions Class See Also
Creates a view based on the specified IObservableSource<(Of <(T>)>) collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    IObservableSource<T> source,
    ViewOrder order
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As IObservableSource(Of T), _
    order As ViewOrder _
) As View(Of T)

Parameters

source
Type: C1.LiveLinq..::.IObservableSource <(Of <(T>)>)
The IObservableSource<(Of <(T>)>) collection to expose as a view.
order
Type: C1.LiveLinq.LiveViews..::.ViewOrder
Specifies whether to preserve source item order.

Type Parameters

T
The type of the elements in the collection.

Return Value

A view that contains the same elements as the IObservableSource<(Of <(T>)>)

Remarks

If the order parameter specifies preserving item order, the order of items in the source is preserved, at a certain performance cost, in the resulting view and in views based on it (for example, if you filter it with Where).

Note that Join does not preserve source order. If you need to order a join result, use OrderBy after Join.

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsLive(T) Method (BindingList(T), ViewOrder)

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (BindingList<(Of <(T>)>), ViewOrder)
LiveViewExtensions Class See Also
A typed specialization of the AsLive<(Of <(T>)>)(IBindingList, ViewOrder) method.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    BindingList<T> source,
    ViewOrder order
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As BindingList(Of T), _
    order As ViewOrder _
) As View(Of T)

Parameters

source
Type: System.ComponentModel..::.BindingList <(Of <(T>)>)
The BindingList<(Of <(T>)>) data source to expose as a view.
order
Type: C1.LiveLinq.LiveViews..::.ViewOrder
Specifies whether to preserve source item order.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the BindingList<(Of <(T>)>).

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsLive(T) Method (IBindingList, ViewOrder)

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsLive<(Of <(T>)>) Method (IBindingList, ViewOrder)
LiveViewExtensions Class See Also
Creates a view based on the specified IBindingList data source.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    IBindingList source,
    ViewOrder order
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As IBindingList, _
    order As ViewOrder _
) As View(Of T)

Parameters

source
Type: System.ComponentModel..::.IBindingList
The IBindingList data source to expose as a view.
order
Type: C1.LiveLinq.LiveViews..::.ViewOrder
Specifies whether to preserve source item order.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the IBindingList.

Remarks

Use this method to build views from existing data sources. The only requirements for the data source is that it implements the standard data binding interface IBindingList.

If the order parameter specifies preserving item order, the order of items in the source is preserved, at a certain performance cost, in the resulting view and in views based on it (for example, if you filter it with Where).

Note that Join does not preserve source order. If you need to order a join result, use OrderBy after Join.

See Also

LiveViewExtensions Class
AsLive Overload
C1.LiveLinq Namespace


AsNonUpdatable(T) Method

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsNonUpdatable<(Of <(T>)>) Method
LiveViewExtensions Class See Also
Specifies a view as read-only.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsNonUpdatable<T>(
    View<T> view
)
Visual Basic (Declaration)
Public Shared Function AsNonUpdatable(Of T) ( _
    view As View(Of T) _
) As View(Of T)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The view to specify as read-only.

Type Parameters

T
The type of the elements in the view.

Return Value

The same view.

See Also

LiveViewExtensions Class
C1.LiveLinq Namespace
LiveViewExtensions..::.AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))


AsUpdatable(T) Method

[image]

.NET Framework Class Library
LiveViewExtensions..::.AsUpdatable<(Of <(T>)>) Method
LiveViewExtensions Class See Also
Specifies a view as updatable.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsUpdatable<T>(
    View<T> view
)
Visual Basic (Declaration)
Public Shared Function AsUpdatable(Of T) ( _
    view As View(Of T) _
) As View(Of T)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The view to specify as updatable.

Type Parameters

T
The type of the elements in the view.

Return Value

The same view.

Remarks

This method is used with Join operation to specify which of the two parts of the join you want to be updatable.

Properties exposed by a view can be updatable or read-only. Updatable properties of a view can be modified directly in the view. Read-only properties of a view cannot be modified directly in the view, but they still reflect up-to-date values of the source, so the difference is often not critical, you can always modify corresponding property in the source, that will automatically change the property in the view.

Only one of the two arguments of a Join can be updatable, the one you qualified with AsUpdatable(). In absence of this qualification, both parts of the join are read-only. For example, in

Copy CodeC#
from c in customers.AsLive()
join o in orders.AsLive().AsUpdatable() on o.CustomerID equals c.CustomerID
select new { c.CustomerName, o.OrderDate, o.OrderAmount }
CustomerName is read-only, and OrderDate and OrderAmount are updatable.

See Also

LiveViewExtensions Class
C1.LiveLinq Namespace
View..::.IsReadOnly
C1.LiveLinq.LiveViews..::.ViewRow
C1.LiveLinq.LiveViews..::.ViewRowState


LiveAggregate Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAggregate Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveAggregate<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TSource, TSource>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TSource, TSource>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TSource, Boolean>)>)>)>)) | Applies an accumulator function over a view.
LiveAggregate<(Of <(TSource, TAccumulate>)>)(View<(Of <(TSource>)>), TAccumulate, Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, Boolean>)>)>)>)) | Applies an accumulator function over a view. The specified seed value is used as the initial accumulator value.
LiveAggregate<(Of <(TSource, TAccumulate, TResult>)>)(View<(Of <(TSource>)>), TAccumulate, Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, Boolean>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TResult>)>)>)>)) | Applies an accumulator function over a view. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveAggregate(TSource) Method (View(TSource), Expression(Func(TSource, TSource, TSource)), Expression(Func(TSource, TSource, TSource)), Expression(Func(TSource, TSource, Boolean)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAggregate<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TSource, TSource>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TSource, TSource>)>)>)>), Expression<(Of <(Func<(Of <(TSource, TSource, Boolean>)>)>)>))
LiveViewExtensions Class See Also
Applies an accumulator function over a view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TSource> LiveAggregate<TSource>(
    View<TSource> source,
    Expression<Func<TSource, TSource, TSource>> funcAdd,
    Expression<Func<TSource, TSource, TSource>> funcRemove,
    Expression<Func<TSource, TSource, bool>> funcRemoveDefined
)
Visual Basic (Declaration)
Public Shared Function LiveAggregate(Of TSource) ( _
    source As View(Of TSource), _
    funcAdd As Expression(Of Func(Of TSource, TSource, TSource)), _
    funcRemove As Expression(Of Func(Of TSource, TSource, TSource)), _
    funcRemoveDefined As Expression(Of Func(Of TSource, TSource, Boolean)) _
) As AggregationView(Of TSource, TSource)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view to aggregate over.
funcAdd
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TSource, TSource>)>)>)>)
An accumulator function to be invoked on each element that is added to the source view.
funcRemove
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TSource, TSource>)>)>)>)
A function to be applied to the accumulated value and to an element to obtain the changed accumulated value, when an element is removed from the source view.
funcRemoveDefined
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TSource, Boolean >)>)>)>)
A function used to determine whether funcRemove must be applied when an element is removed from the source view, or the accumulated value is not affected by its removal.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the final accumulator value.

Remarks

It is possible to use standard LINQ query operator Aggregate instead of LiveAggregate. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Aggregate will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAggregate will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAggregate Overload
C1.LiveLinq Namespace


LiveAggregate(TSource, TAccumulate) Method (View(TSource), TAccumulate, Expression(Func(TAccumulate, TSource, TAccumulate)), Expression(Func(TAccumulate, TSource, TAccumulate)), Expression(Func(TAccumulate, TSource, Boolean)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAggregate<(Of <(TSource, TAccumulate>)>) Method (View<(Of <(TSource>)>), TAccumulate, Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, Boolean>)>)>)>))
LiveViewExtensions Class See Also
Applies an accumulator function over a view. The specified seed value is used as the initial accumulator value.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TAccumulate> LiveAggregate<TSource, TAccumulate>(
    View<TSource> source,
    TAccumulate seed,
    Expression<Func<TAccumulate, TSource, TAccumulate>> funcAdd,
    Expression<Func<TAccumulate, TSource, TAccumulate>> funcRemove,
    Expression<Func<TAccumulate, TSource, bool>> funcRemoveDefined
)
Visual Basic (Declaration)
Public Shared Function LiveAggregate(Of TSource, TAccumulate) ( _
    source As View(Of TSource), _
    seed As TAccumulate, _
    funcAdd As Expression(Of Func(Of TAccumulate, TSource, TAccumulate)), _
    funcRemove As Expression(Of Func(Of TAccumulate, TSource, TAccumulate)), _
    funcRemoveDefined As Expression(Of Func(Of TAccumulate, TSource, Boolean)) _
) As AggregationView(Of TSource, TAccumulate)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view to aggregate over.
seed
Type: TAccumulate
The initial accumulator value.
funcAdd
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, TAccumulate>)>)>)>)
An accumulator function to be invoked on each element that is added to the source view.
funcRemove
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, TAccumulate>)>)>)>)
A function to be applied to the accumulated value and to an element to obtain the changed accumulated value, when an element is removed from the source view.
funcRemoveDefined
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, Boolean >)>)>)>)
A function used to determine whether funcRemove must be applied when an element is removed from the source view, or the accumulated value is not affected by its removal.

Type Parameters

TSource
The type of the elements of source.
TAccumulate
The type of the accumulator value.

Return Value

A view representing the final accumulator value.

Remarks

It is possible to use standard LINQ query operator Aggregate instead of LiveAggregate. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Aggregate will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAggregate will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAggregate Overload
C1.LiveLinq Namespace


LiveAggregate(TSource, TAccumulate, TResult) Method (View(TSource), TAccumulate, Expression(Func(TAccumulate, TSource, TAccumulate)), Expression(Func(TAccumulate, TSource, TAccumulate)), Expression(Func(TAccumulate, TSource, Boolean)), Expression(Func(TAccumulate, TResult)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAggregate<(Of <(TSource, TAccumulate, TResult>)>) Method (View<(Of <(TSource>)>), TAccumulate, Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, TAccumulate>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TSource, Boolean>)>)>)>), Expression<(Of <(Func<(Of <(TAccumulate, TResult>)>)>)>))
LiveViewExtensions Class See Also
Applies an accumulator function over a view. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TResult> LiveAggregate<TSource, TAccumulate, TResult>(
    View<TSource> source,
    TAccumulate seed,
    Expression<Func<TAccumulate, TSource, TAccumulate>> funcAdd,
    Expression<Func<TAccumulate, TSource, TAccumulate>> funcRemove,
    Expression<Func<TAccumulate, TSource, bool>> funcRemoveDefined,
    Expression<Func<TAccumulate, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Shared Function LiveAggregate(Of TSource, TAccumulate, TResult) ( _
    source As View(Of TSource), _
    seed As TAccumulate, _
    funcAdd As Expression(Of Func(Of TAccumulate, TSource, TAccumulate)), _
    funcRemove As Expression(Of Func(Of TAccumulate, TSource, TAccumulate)), _
    funcRemoveDefined As Expression(Of Func(Of TAccumulate, TSource, Boolean)), _
    resultSelector As Expression(Of Func(Of TAccumulate, TResult)) _
) As AggregationView(Of TSource, TResult)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view to aggregate over.
seed
Type: TAccumulate
The initial accumulator value.
funcAdd
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, TAccumulate>)>)>)>)
An accumulator function to be invoked on each element that is added to the source view.
funcRemove
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, TAccumulate>)>)>)>)
A function to be applied to the accumulated value and to an element to obtain the changed accumulated value, when an element is removed from the source view.
funcRemoveDefined
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TSource, Boolean >)>)>)>)
A function used to determine whether funcRemove must be applied when an element is removed from the source view, or the accumulated value is not affected by its removal.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TAccumulate, TResult>)>)>)>)
A function to transform the final accumulator value into the result value.

Type Parameters

TSource
The type of the elements of source.
TAccumulate
The type of the accumulator value.
TResult
The type of the resulting value.

Return Value

A view representing the final accumulator value.

Remarks

It is possible to use standard LINQ query operator Aggregate instead of LiveAggregate. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Aggregate will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAggregate will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAggregate Overload
C1.LiveLinq Namespace


LiveAverage Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveAverage(View<(Of <(Decimal>)>)) | Computes the average of a view of Decimal values.
LiveAverage(View<(Of <(Double>)>)) | Computes the average of a view of Double values.
LiveAverage(View<(Of <(Int32>)>)) | Computes the average of a view of Int32 values.
LiveAverage(View<(Of <(Int64>)>)) | Computes the average of a view of Int64 values.
LiveAverage(View<(Of <(Nullable<(Of <(Decimal>)>)>)>)) | Computes the average of a view of nullable Decimal values.
LiveAverage(View<(Of <(Nullable<(Of <(Double>)>)>)>)) | Computes the average of a view of nullable Double values.
LiveAverage(View<(Of <(Nullable<(Of <(Int32>)>)>)>)) | Computes the average of a view of nullable Int32 values.
LiveAverage(View<(Of <(Nullable<(Of <(Int64>)>)>)>)) | Computes the average of a view of nullable Int64 values.
LiveAverage(View<(Of <(Nullable<(Of <(Single>)>)>)>)) | Computes the average of a view of nullable Single values.
LiveAverage(View<(Of <(Single>)>)) | Computes the average of a view of Single values.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>)) | Computes the average of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>)) | Computes the average of a view of Double values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>)) | Computes the average of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>)) | Computes the average of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>)) | Computes the average of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>)) | Computes the average of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>)) | Computes the average of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>)) | Computes the average of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>)) | Computes the average of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.
LiveAverage<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>)) | Computes the average of a view of Single values that are obtained by invoking a transform function on each element of the source view.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveAverage Method (View(Decimal))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Decimal>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<decimal, decimal> LiveAverage(
    View<decimal> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Decimal) _
) As AggregationView(Of Decimal, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Decimal >)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average 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 Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Double))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Double>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<double, double> LiveAverage(
    View<double> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Double) _
) As AggregationView(Of Double, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Double >)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average 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 Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Int32))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Int32>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<int, double> LiveAverage(
    View<int> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Integer) _
) As AggregationView(Of Integer, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int32 >)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average 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 Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Int64))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Int64>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<long, double> LiveAverage(
    View<long> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Long) _
) As AggregationView(Of Long, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int64 >)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average 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 Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Nullable(Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Nullable<(Of <(Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<decimal>, Nullable<decimal>> LiveAverage(
    View<Nullable<decimal>> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Nullable(Of Decimal)) _
) As AggregationView(Of Nullable(Of Decimal), Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Decimal >)>)>)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average of the values.

Remarks

If the source is empty or contains only nulls, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Nullable(Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Nullable<(Of <(Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<double>, Nullable<double>> LiveAverage(
    View<Nullable<double>> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Nullable(Of Double)) _
) As AggregationView(Of Nullable(Of Double), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Double >)>)>)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average of the values.

Remarks

If the source is empty or contains only nulls, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Nullable(Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Nullable<(Of <(Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<int>, Nullable<double>> LiveAverage(
    View<Nullable<int>> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Nullable(Of Integer)) _
) As AggregationView(Of Nullable(Of Integer), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int32 >)>)>)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average of the values.

Remarks

If the source is empty or contains only nulls, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Nullable(Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Nullable<(Of <(Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<long>, Nullable<double>> LiveAverage(
    View<Nullable<long>> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Nullable(Of Long)) _
) As AggregationView(Of Nullable(Of Long), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int64 >)>)>)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average of the values.

Remarks

If the source is empty or contains only nulls, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Nullable(Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Nullable<(Of <(Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<float>, Nullable<double>> LiveAverage(
    View<Nullable<float>> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Nullable(Of Single)) _
) As AggregationView(Of Nullable(Of Single), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Single >)>)>)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average of the values.

Remarks

If the source is empty or contains only nulls, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage Method (View(Single))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage Method (View<(Of <(Single>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<float, double> LiveAverage(
    View<float> source
)
Visual Basic (Declaration)
Public Shared Function LiveAverage ( _
    source As View(Of Single) _
) As AggregationView(Of Single, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Single >)>)
A view containing the values to calculate the average of.

Return Value

A view representing the average 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 Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, decimal> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, decimal>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Decimal)) _
) As AggregationView(Of TSource, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Decimal >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, double>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Double)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Double >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, int>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Integer)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int32 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, long>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Long)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int64 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Decimal))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<decimal>> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<decimal>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Decimal))) _
) As AggregationView(Of TSource, Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Decimal >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Double))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<double>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Double))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Double >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int32))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<int>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Integer))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int32 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int64))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<long>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Long))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int64 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Single))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<float>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Single))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Single >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, the average value is null.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveAverage(TSource) Method (View(TSource), Expression(Func(TSource, Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveAverage<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the average of a view of Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveAverage<TSource>(
    View<TSource> source,
    Expression<Func<TSource, float>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveAverage(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Single)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the average of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Single >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the average of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Average instead of LiveAverage. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Average will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAverage will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveAverage Overload
C1.LiveLinq Namespace


LiveCount Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveCount Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveCount<(Of <(T>)>)(View<(Of <(T>)>)) | A view representing the number of elements in a view.
LiveCount<(Of <(T>)>)(View<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>)) | A view representing the number of elements of the specified view satisfying a condition.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveCount(T) Method (View(T))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveCount<(Of <(T>)>) Method (View<(Of <(T>)>))
LiveViewExtensions Class See Also
A view representing the number of elements in a view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<T, int> LiveCount<T>(
    View<T> source
)
Visual Basic (Declaration)
Public Shared Function LiveCount(Of T) ( _
    source As View(Of T) _
) As AggregationView(Of T, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
A view that contains elements to be counted.

Type Parameters

T
The type of the elements of source.

Remarks

It is possible to use standard LINQ query operator Aggregate instead of LiveAggregate. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Aggregate will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAggregate will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveCount Overload
C1.LiveLinq Namespace


LiveCount(T) Method (View(T), Expression(Func(T, Boolean)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveCount<(Of <(T>)>) Method (View<(Of <(T>)>), Expression<(Of <(Func<(Of <(T, Boolean>)>)>)>))
LiveViewExtensions Class See Also
A view representing the number of elements of the specified view satisfying a condition.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<T, int> LiveCount<T>(
    View<T> source,
    Expression<Func<T, bool>> predicate
)
Visual Basic (Declaration)
Public Shared Function LiveCount(Of T) ( _
    source As View(Of T), _
    predicate As Expression(Of Func(Of T, Boolean)) _
) As AggregationView(Of T, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
A view that contains elements to be tested and counted.
predicate
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, Boolean >)>)>)>)
A function to test each element for a condition.

Type Parameters

T
The type of the elements of source.

Remarks

It is possible to use standard LINQ query operator Aggregate instead of LiveAggregate. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Aggregate will every time loop through the entire source collection and aggregate it from scratch, whereas LiveAggregate will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveCount Overload
C1.LiveLinq Namespace


LiveMax Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveMax(View<(Of <(Decimal>)>)) | Computes the maximum value of a view of Decimal values.
LiveMax(View<(Of <(Double>)>)) | Computes the maximum value of a view of Double values.
LiveMax(View<(Of <(Int32>)>)) | Computes the maximum value of a view of Int32 values.
LiveMax(View<(Of <(Int64>)>)) | Computes the maximum value of a view of Int64 values.
LiveMax(View<(Of <(Nullable<(Of <(Decimal>)>)>)>)) | Computes the maximum value of a view of nullable Decimal values.
LiveMax(View<(Of <(Nullable<(Of <(Double>)>)>)>)) | Computes the maximum value of a view of nullable Double values.
LiveMax(View<(Of <(Nullable<(Of <(Int32>)>)>)>)) | Computes the maximum value of a view of nullable Int32 values.
LiveMax(View<(Of <(Nullable<(Of <(Int64>)>)>)>)) | Computes the maximum value of a view of nullable Int64 values.
LiveMax(View<(Of <(Nullable<(Of <(Single>)>)>)>)) | Computes the maximum value of a view of nullable Single values.
LiveMax(View<(Of <(Single>)>)) | Computes the maximum value of a view of Single values.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>)) | Computes the maximum value of a view of elements of a generic type.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>)) | Computes the maximum value of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>)) | Computes the maximum value of a view of Double values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>)) | Computes the maximum value of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>)) | Computes the maximum value of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>)) | Computes the maximum value of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>)) | Computes the maximum value of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>)) | Computes the maximum value of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>)) | Computes the maximum value of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>)) | Computes the maximum value of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>)) | Computes the maximum value of a view of Single values that are obtained by invoking a transform function on each element of the source view.
LiveMax<(Of <(TSource, TResult>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TResult>)>)>)>)) | Invokes a transform function on each element of a view of elements of a generic type and computes the maximum resulting value.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveMax Method (View(Decimal))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Decimal>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<decimal, decimal> LiveMax(
    View<decimal> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Decimal) _
) As AggregationView(Of Decimal, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Decimal >)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum 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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Double))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Double>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<double, double> LiveMax(
    View<double> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Double) _
) As AggregationView(Of Double, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Double >)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum 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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Int32))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Int32>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<int, int> LiveMax(
    View<int> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Integer) _
) As AggregationView(Of Integer, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int32 >)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum 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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Int64))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Int64>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<long, long> LiveMax(
    View<long> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Long) _
) As AggregationView(Of Long, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int64 >)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum 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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Nullable(Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Nullable<(Of <(Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<decimal>, Nullable<decimal>> LiveMax(
    View<Nullable<decimal>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Nullable(Of Decimal)) _
) As AggregationView(Of Nullable(Of Decimal), Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Decimal >)>)>)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Nullable(Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Nullable<(Of <(Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<double>, Nullable<double>> LiveMax(
    View<Nullable<double>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Nullable(Of Double)) _
) As AggregationView(Of Nullable(Of Double), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Double >)>)>)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Nullable(Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Nullable<(Of <(Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<int>, Nullable<int>> LiveMax(
    View<Nullable<int>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Nullable(Of Integer)) _
) As AggregationView(Of Nullable(Of Integer), Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int32 >)>)>)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Nullable(Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Nullable<(Of <(Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<long>, Nullable<long>> LiveMax(
    View<Nullable<long>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Nullable(Of Long)) _
) As AggregationView(Of Nullable(Of Long), Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int64 >)>)>)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Nullable(Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Nullable<(Of <(Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<float>, Nullable<float>> LiveMax(
    View<Nullable<float>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Nullable(Of Single)) _
) As AggregationView(Of Nullable(Of Single), Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Single >)>)>)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax Method (View(Single))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax Method (View<(Of <(Single>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<float, float> LiveMax(
    View<float> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax ( _
    source As View(Of Single) _
) As AggregationView(Of Single, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Single >)>)
A view containing the values to determine the maximum value of.

Return Value

A view representing the maximum 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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of elements of a generic type.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TSource> LiveMax<TSource>(
    View<TSource> source
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource) _
) As AggregationView(Of TSource, TSource)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If type TSource implements IComparable<(Of <(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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, decimal> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, decimal>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Decimal)) _
) As AggregationView(Of TSource, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Decimal >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, double>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Double)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Double >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, int> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, int>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Integer)) _
) As AggregationView(Of TSource, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int32 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, long> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, long>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Long)) _
) As AggregationView(Of TSource, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int64 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Decimal))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<decimal>> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<decimal>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Decimal))) _
) As AggregationView(Of TSource, Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Decimal >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Double))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<double>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Double))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Double >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int32))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<int>> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<int>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Integer))) _
) As AggregationView(Of TSource, Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int32 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int64))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<long>> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<long>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Long))) _
) As AggregationView(Of TSource, Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int64 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Single))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<float>> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<float>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Single))) _
) As AggregationView(Of TSource, Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Single >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty or contains only nulls, the maximum value is null.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource) Method (View(TSource), Expression(Func(TSource, Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the maximum value of a view of Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, float> LiveMax<TSource>(
    View<TSource> source,
    Expression<Func<TSource, float>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMax(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Single)) _
) As AggregationView(Of TSource, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Single >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the maximum of the values.

Remarks

If the source is empty, an InvalidOperationException is thrown.

It is possible to use standard LINQ query operator Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMax(TSource, TResult) Method (View(TSource), Expression(Func(TSource, TResult)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMax<(Of <(TSource, TResult>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TResult>)>)>)>))
LiveViewExtensions Class See Also
Invokes a transform function on each element of a view of elements of a generic type and computes the maximum resulting value.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TResult> LiveMax<TSource, TResult>(
    View<TSource> source,
    Expression<Func<TSource, TResult>> selector
)
Visual Basic (Declaration)
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)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the maximum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TResult>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.
TResult
The type of the value returned by selector.

Return Value

A view representing the maximum of the values.

Remarks

If type TResult implements IComparable<(Of <(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 Max 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 Max 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.

See Also

LiveViewExtensions Class
LiveMax Overload
C1.LiveLinq Namespace


LiveMin Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveMin(View<(Of <(Decimal>)>)) | Computes the minimum value of a view of Decimal values.
LiveMin(View<(Of <(Double>)>)) | Computes the minimum value of a view of Double values.
LiveMin(View<(Of <(Int32>)>)) | Computes the minimum value of a view of Int32 values.
LiveMin(View<(Of <(Int64>)>)) | Computes the minimum value of a view of Int64 values.
LiveMin(View<(Of <(Nullable<(Of <(Decimal>)>)>)>)) | Computes the minimum value of a view of nullable Decimal values.
LiveMin(View<(Of <(Nullable<(Of <(Double>)>)>)>)) | Computes the minimum value of a view of nullable Double values.
LiveMin(View<(Of <(Nullable<(Of <(Int32>)>)>)>)) | Computes the minimum value of a view of nullable Int32 values.
LiveMin(View<(Of <(Nullable<(Of <(Int64>)>)>)>)) | Computes the minimum value of a view of nullable Int64 values.
LiveMin(View<(Of <(Nullable<(Of <(Single>)>)>)>)) | Computes the minimum value of a view of nullable Single values.
LiveMin(View<(Of <(Single>)>)) | Computes the minimum value of a view of Single values.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>)) | Computes the minimum value of a view of elements of a generic type.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(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.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(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.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>)) | Computes the minimum value of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>)) | Computes the minimum value of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(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.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(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.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>)) | Computes the minimum value of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>)) | Computes the minimum value of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>)) | Computes the minimum value of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>)) | Computes the minimum value of a view of Single values that are obtained by invoking a transform function on each element of the source view.
LiveMin<(Of <(TSource, TResult>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TResult>)>)>)>)) | Invokes a transform function on each element of a view of elements of a generic type and computes the minimum resulting value.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveMin Method (View(Decimal))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Decimal>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<decimal, decimal> LiveMin(
    View<decimal> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Decimal) _
) As AggregationView(Of Decimal, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Decimal >)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Double))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Double>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<double, double> LiveMin(
    View<double> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Double) _
) As AggregationView(Of Double, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Double >)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Int32))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Int32>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<int, int> LiveMin(
    View<int> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Integer) _
) As AggregationView(Of Integer, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int32 >)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Int64))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Int64>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<long, long> LiveMin(
    View<long> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Long) _
) As AggregationView(Of Long, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int64 >)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Nullable(Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Nullable<(Of <(Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<decimal>, Nullable<decimal>> LiveMin(
    View<Nullable<decimal>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Nullable(Of Decimal)) _
) As AggregationView(Of Nullable(Of Decimal), Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Decimal >)>)>)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Nullable(Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Nullable<(Of <(Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<double>, Nullable<double>> LiveMin(
    View<Nullable<double>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Nullable(Of Double)) _
) As AggregationView(Of Nullable(Of Double), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Double >)>)>)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Nullable(Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Nullable<(Of <(Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<int>, Nullable<int>> LiveMin(
    View<Nullable<int>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Nullable(Of Integer)) _
) As AggregationView(Of Nullable(Of Integer), Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int32 >)>)>)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Nullable(Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Nullable<(Of <(Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<long>, Nullable<long>> LiveMin(
    View<Nullable<long>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Nullable(Of Long)) _
) As AggregationView(Of Nullable(Of Long), Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int64 >)>)>)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Nullable(Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Nullable<(Of <(Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<float>, Nullable<float>> LiveMin(
    View<Nullable<float>> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Nullable(Of Single)) _
) As AggregationView(Of Nullable(Of Single), Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Single >)>)>)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin Method (View(Single))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin Method (View<(Of <(Single>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<float, float> LiveMin(
    View<float> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin ( _
    source As View(Of Single) _
) As AggregationView(Of Single, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Single >)>)
A view containing the values to determine the minimum value of.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of elements of a generic type.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TSource> LiveMin<TSource>(
    View<TSource> source
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource) _
) As AggregationView(Of TSource, TSource)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

Remarks

If type TSource implements IComparable<(Of <(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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>))
LiveViewExtensions Class See Also
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.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, decimal> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, decimal>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Decimal)) _
) As AggregationView(Of TSource, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Decimal >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>))
LiveViewExtensions Class See Also
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.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, double>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Double)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Double >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, int> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, int>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Integer)) _
) As AggregationView(Of TSource, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int32 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, long> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, long>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Long)) _
) As AggregationView(Of TSource, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int64 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Decimal))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>))
LiveViewExtensions Class See Also
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.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<decimal>> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<decimal>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Decimal))) _
) As AggregationView(Of TSource, Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Decimal >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Double))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>))
LiveViewExtensions Class See Also
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.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<double>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Double))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Double >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int32))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<int>> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<int>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Integer))) _
) As AggregationView(Of TSource, Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int32 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int64))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<long>> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<long>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Long))) _
) As AggregationView(Of TSource, Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int64 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Single))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<float>> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<float>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Single))) _
) As AggregationView(Of TSource, Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Single >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource) Method (View(TSource), Expression(Func(TSource, Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the minimum value of a view of Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, float> LiveMin<TSource>(
    View<TSource> source,
    Expression<Func<TSource, float>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Single)) _
) As AggregationView(Of TSource, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Single >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the minimum of the values.

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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveMin(TSource, TResult) Method (View(TSource), Expression(Func(TSource, TResult)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveMin<(Of <(TSource, TResult>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, TResult>)>)>)>))
LiveViewExtensions Class See Also
Invokes a transform function on each element of a view of elements of a generic type and computes the minimum resulting value.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, TResult> LiveMin<TSource, TResult>(
    View<TSource> source,
    Expression<Func<TSource, TResult>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveMin(Of TSource, TResult) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, TResult)) _
) As AggregationView(Of TSource, TResult)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to determine the minimum value of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, TResult>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.
TResult
The type of the value returned by selector.

Return Value

A view representing the minimum of the values.

Remarks

If type TResult implements IComparable<(Of <(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.

See Also

LiveViewExtensions Class
LiveMin Overload
C1.LiveLinq Namespace


LiveSum Method

[image] [image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method
LiveViewExtensions Class See Also

Overload List

Name | Description
LiveSum(View<(Of <(Decimal>)>)) | Computes the sum of a view of Decimal values.
LiveSum(View<(Of <(Double>)>)) | Computes the sum of a view of Double values.
LiveSum(View<(Of <(Int32>)>)) | Computes the sum of a view of Int32 values.
LiveSum(View<(Of <(Int64>)>)) | Computes the sum of a view of Int64 values.
LiveSum(View<(Of <(Nullable<(Of <(Decimal>)>)>)>)) | Computes the sum of a view of nullable Decimal values.
LiveSum(View<(Of <(Nullable<(Of <(Double>)>)>)>)) | Computes the sum of a view of nullable Double values.
LiveSum(View<(Of <(Nullable<(Of <(Int32>)>)>)>)) | Computes the sum of a view of nullable Int32 values.
LiveSum(View<(Of <(Nullable<(Of <(Int64>)>)>)>)) | Computes the sum of a view of nullable Int64 values.
LiveSum(View<(Of <(Nullable<(Of <(Single>)>)>)>)) | Computes the sum of a view of nullable Single values.
LiveSum(View<(Of <(Single>)>)) | Computes the sum of a view of Single values.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>)) | Computes the sum of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>)) | Computes the sum of a view of Double values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>)) | Computes the sum of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>)) | Computes the sum of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>)) | Computes the sum of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>)) | Computes the sum of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>)) | Computes the sum of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>)) | Computes the sum of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>)) | Computes the sum of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.
LiveSum<(Of <(TSource>)>)(View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>)) | Computes the sum of a view of Single values that are obtained by invoking a transform function on each element of the source view.

See Also

LiveViewExtensions Class
LiveViewExtensions Members
C1.LiveLinq Namespace


LiveSum Method (View(Decimal))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Decimal>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<decimal, decimal> LiveSum(
    View<decimal> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Decimal) _
) As AggregationView(Of Decimal, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Decimal >)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Double))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Double>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<double, double> LiveSum(
    View<double> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Double) _
) As AggregationView(Of Double, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Double >)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Int32))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Int32>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<int, int> LiveSum(
    View<int> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Integer) _
) As AggregationView(Of Integer, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int32 >)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Int64))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Int64>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<long, long> LiveSum(
    View<long> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Long) _
) As AggregationView(Of Long, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Int64 >)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Nullable(Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Nullable<(Of <(Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Decimal values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<decimal>, Nullable<decimal>> LiveSum(
    View<Nullable<decimal>> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Nullable(Of Decimal)) _
) As AggregationView(Of Nullable(Of Decimal), Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Decimal >)>)>)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Nullable(Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Nullable<(Of <(Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Double values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<double>, Nullable<double>> LiveSum(
    View<Nullable<double>> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Nullable(Of Double)) _
) As AggregationView(Of Nullable(Of Double), Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Double >)>)>)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Nullable(Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Nullable<(Of <(Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Int32 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<int>, Nullable<int>> LiveSum(
    View<Nullable<int>> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Nullable(Of Integer)) _
) As AggregationView(Of Nullable(Of Integer), Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int32 >)>)>)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Nullable(Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Nullable<(Of <(Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Int64 values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<long>, Nullable<long>> LiveSum(
    View<Nullable<long>> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Nullable(Of Long)) _
) As AggregationView(Of Nullable(Of Long), Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Int64 >)>)>)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Nullable(Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Nullable<(Of <(Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<Nullable<float>, Nullable<float>> LiveSum(
    View<Nullable<float>> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Nullable(Of Single)) _
) As AggregationView(Of Nullable(Of Single), Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Nullable <(Of <( Single >)>)>)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum Method (View(Single))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum Method (View<(Of <(Single>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Single values.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<float, float> LiveSum(
    View<float> source
)
Visual Basic (Declaration)
Public Shared Function LiveSum ( _
    source As View(Of Single) _
) As AggregationView(Of Single, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <( Single >)>)
A view containing the values to calculate the sum of.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Decimal)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Decimal>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, decimal> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, decimal>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Decimal)) _
) As AggregationView(Of TSource, Decimal)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Decimal >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Double)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Double>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, double> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, double>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Double)) _
) As AggregationView(Of TSource, Double)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Double >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Int32)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int32>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, int> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, int>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Integer)) _
) As AggregationView(Of TSource, Integer)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int32 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Int64)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Int64>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, long> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, long>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Long)) _
) As AggregationView(Of TSource, Long)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Int64 >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Decimal))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Decimal>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Decimal values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<decimal>> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<decimal>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Decimal))) _
) As AggregationView(Of TSource, Nullable(Of Decimal))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Decimal >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Double))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Double>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Double values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<double>> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<double>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Double))) _
) As AggregationView(Of TSource, Nullable(Of Double))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Double >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int32))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int32>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Int32 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<int>> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<int>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Integer))) _
) As AggregationView(Of TSource, Nullable(Of Integer))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int32 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Int64))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Int64>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Int64 values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<long>> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<long>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Long))) _
) As AggregationView(Of TSource, Nullable(Of Long))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Int64 >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Nullable(Single))))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Nullable<(Of <(Single>)>)>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of nullable Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, Nullable<float>> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, Nullable<float>>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Nullable(Of Single))) _
) As AggregationView(Of TSource, Nullable(Of Single))

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Nullable <(Of <( Single >)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


LiveSum(TSource) Method (View(TSource), Expression(Func(TSource, Single)))

[image]

.NET Framework Class Library
LiveViewExtensions..::.LiveSum<(Of <(TSource>)>) Method (View<(Of <(TSource>)>), Expression<(Of <(Func<(Of <(TSource, Single>)>)>)>))
LiveViewExtensions Class See Also
Computes the sum of a view of Single values that are obtained by invoking a transform function on each element of the source view.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static AggregationView<TSource, float> LiveSum<TSource>(
    View<TSource> source,
    Expression<Func<TSource, float>> selector
)
Visual Basic (Declaration)
Public Shared Function LiveSum(Of TSource) ( _
    source As View(Of TSource), _
    selector As Expression(Of Func(Of TSource, Single)) _
) As AggregationView(Of TSource, Single)

Parameters

source
Type: C1.LiveLinq.LiveViews..::.View <(Of <(TSource>)>)
A view containing the values to calculate the sum of.
selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TSource, Single >)>)>)>)
A transform function to apply to each element.

Type Parameters

TSource
The type of the elements of source.

Return Value

A view representing the sum of the values.

Remarks

If the source is empty or contains only nulls, the sum value is zero.

It is possible to use standard LINQ query operator Sum instead of LiveSum. Both are "live" in the sense that they are recomputed automatically when any change occurs in the source. The difference is that Sum will every time loop through the entire source collection and aggregate it from scratch, whereas LiveSum will use a more performant algorithm, will maintain its value incrementally, processing only those source items that actually changed.

See Also

LiveViewExtensions Class
LiveSum Overload
C1.LiveLinq Namespace


Order Enumeration

[image]

.NET Framework Class Library
Order Enumeration
See Also
Indicates if a certain order is required in the result collection of an operation.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum Order
Visual Basic (Declaration)
Public Enumeration Order

Members

Member name | Description
Unordered | No particular order is required in the resulting collection.
Ascending | The resulting collection must be ordered in ascending key order.
Descending | The resulting collection must be ordered in descending key order.

See Also

C1.LiveLinq Namespace


Ordering(T) Class

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>) Class
Members See Also
Represents a sorted IIndexedSource<(Of <(T>)>).

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class Ordering<T> : IIndexedSource<T>,
    IEnumerable<T>, IEnumerable
Visual Basic (Declaration)
Public Class Ordering(Of T) _
    Implements IIndexedSource(Of T), IEnumerable(Of T),  _
    IEnumerable

Type Parameters

T
The type of the elements of the collection.

Remarks

An Ordering<T> can be obtained as a result of an OrderBy or OrderByDescending query operator. Query operators (extension methods) ThenBy and ThenByDescending operate on objects of type Ordering<T>.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq..::.Ordering<(Of <(T>)>)

See Also

Ordering<(Of <(T>)>) Members
C1.LiveLinq Namespace


Ordering(T) Members

[image] [image]

.NET Framework Class Library
Ordering<(Of <(T>)>) Members
Ordering<(Of <(T>)>) Class Methods See Also

The Ordering<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the Ordering<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ThenBy<(Of <(TKey>)>) | Performs a subsequent ordering of the elements in a collection in ascending order according to a key.
ThenByDescending<(Of <(TKey>)>) | Performs a subsequent ordering of the elements in a collection in descending order according to a key.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


Ordering(T) Methods

[image] [image]

.NET Framework Class Library
Ordering<(Of <(T>)>) Methods
Ordering<(Of <(T>)>) Class See Also

The Ordering<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the Ordering<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ThenBy<(Of <(TKey>)>) | Performs a subsequent ordering of the elements in a collection in ascending order according to a key.
ThenByDescending<(Of <(TKey>)>) | Performs a subsequent ordering of the elements in a collection in descending order according to a key.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>)..::.GetEnumerator Method
Ordering<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the Ordering<(Of <(T>)>).

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerator<T> GetEnumerator()
Visual Basic (Declaration)
Public Function GetEnumerator As IEnumerator(Of T)

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


ThenBy(TKey) Method

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>)..::.ThenBy<(Of <(TKey>)>) Method
Ordering<(Of <(T>)>) Class See Also
Performs a subsequent ordering of the elements in a collection in ascending order according to a key.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Ordering<T> ThenBy<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function ThenBy(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Ordering(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from each element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A collection whose elements are sorted according to a key.

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


ThenByDescending(TKey) Method

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>)..::.ThenByDescending<(Of <(TKey>)>) Method
Ordering<(Of <(T>)>) Class See Also
Performs a subsequent ordering of the elements in a collection in descending order according to a key.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Ordering<T> ThenByDescending<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function ThenByDescending(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Ordering(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from each element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A collection whose elements are sorted in descending order according to a key.

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


QueryOptimizationException Class

[image]

.NET Framework Class Library
QueryOptimizationException Class
Members See Also
Represents an exception that is thrown when Hints in a query require using a certain mandatory optimization which is impossible in the current query context.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
[SerializableAttribute]
public class QueryOptimizationException : Exception
Visual Basic (Declaration)
<SerializableAttribute> _
Public Class QueryOptimizationException _
    Inherits Exception

Inheritance Hierarchy

System..::.Object
System..::.Exception
C1.LiveLinq..::.QueryOptimizationException

See Also

QueryOptimizationException Members
C1.LiveLinq Namespace


QueryOptimizationException Members

[image] [image]

.NET Framework Class Library
QueryOptimizationException Members
QueryOptimizationException Class Constructors Methods Properties See Also

The QueryOptimizationException type exposes the following members.

Constructors

Name | Description
QueryOptimizationException | Overloaded.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

QueryOptimizationException Class
C1.LiveLinq Namespace


QueryOptimizationException Constructor

[image] [image]

.NET Framework Class Library
QueryOptimizationException Constructor
QueryOptimizationException Class See Also

Overload List

Name | Description
QueryOptimizationException()()() | Initializes a new instance of the QueryOptimizationException class. This is the default constructor.
QueryOptimizationException(String) | Initializes a new instance of the QueryOptimizationException class with the specified string.
QueryOptimizationException(SerializationInfo, StreamingContext) | Initializes a new instance of the QueryOptimizationException class from serialized data.
QueryOptimizationException(String, Exception) | Initializes a new instance of the QueryOptimizationException class using the specified string and inner exception.

See Also

QueryOptimizationException Class
QueryOptimizationException Members
C1.LiveLinq Namespace


QueryOptimizationException Constructor

[image]

.NET Framework Class Library
QueryOptimizationException Constructor
QueryOptimizationException Class See Also
Initializes a new instance of the QueryOptimizationException class. This is the default constructor.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public QueryOptimizationException()
Visual Basic (Declaration)
Public Sub New

See Also

QueryOptimizationException Class
QueryOptimizationException Overload
C1.LiveLinq Namespace


QueryOptimizationException Constructor (String)

[image]

.NET Framework Class Library
QueryOptimizationException Constructor (String)
QueryOptimizationException Class See Also
Initializes a new instance of the QueryOptimizationException class with the specified string.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public QueryOptimizationException(
    string message
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.

See Also

QueryOptimizationException Class
QueryOptimizationException Overload
C1.LiveLinq Namespace


QueryOptimizationException Constructor (SerializationInfo, StreamingContext)

[image]

.NET Framework Class Library
QueryOptimizationException Constructor (SerializationInfo, StreamingContext)
QueryOptimizationException Class See Also
Initializes a new instance of the QueryOptimizationException class from serialized data.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected QueryOptimizationException(
    SerializationInfo info,
    StreamingContext context
)
Visual Basic (Declaration)
Protected Sub New ( _
    info As SerializationInfo, _
    context As StreamingContext _
)

Parameters

info
Type: System.Runtime.Serialization..::.SerializationInfo
The object that holds the serialized object data.
context
Type: System.Runtime.Serialization..::.StreamingContext
The contextual information about the source or destination.

See Also

QueryOptimizationException Class
QueryOptimizationException Overload
C1.LiveLinq Namespace


QueryOptimizationException Constructor (String, Exception)

[image]

.NET Framework Class Library
QueryOptimizationException Constructor (String, Exception)
QueryOptimizationException Class See Also
Initializes a new instance of the QueryOptimizationException class using the specified string and inner exception.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public QueryOptimizationException(
    string message,
    Exception inner
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String, _
    inner As Exception _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.
inner
Type: System..::.Exception
Gets the Exception instance that caused the current exception.

See Also

QueryOptimizationException Class
QueryOptimizationException Overload
C1.LiveLinq Namespace


QueryOptimizationException Methods

[image] [image]

.NET Framework Class Library
QueryOptimizationException Methods
QueryOptimizationException Class See Also

The QueryOptimizationException type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

See Also

QueryOptimizationException Class
C1.LiveLinq Namespace


QueryOptimizationException Properties

[image] [image]

.NET Framework Class Library
QueryOptimizationException Properties
QueryOptimizationException Class See Also

The QueryOptimizationException type exposes the following members.

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

QueryOptimizationException Class
C1.LiveLinq Namespace


SourceChangeEventArgs(T) Class

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>) Class
Members See Also
Provides data for the Changing and Changed events.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class SourceChangeEventArgs<T> : EventArgs,
    IEquatable<SourceChangeEventArgs<T>>
Visual Basic (Declaration)
Public Class SourceChangeEventArgs(Of T) _
    Inherits EventArgs _
    Implements IEquatable(Of SourceChangeEventArgs(Of T))

Type Parameters

T
Type of the changed object.

Inheritance Hierarchy

System..::.Object
System..::.EventArgs
C1.LiveLinq..::.SourceChangeEventArgs<(Of <(T>)>)

See Also

SourceChangeEventArgs<(Of <(T>)>) Members
C1.LiveLinq Namespace


SourceChangeEventArgs(T) Members

[image] [image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>) Members
SourceChangeEventArgs<(Of <(T>)>) Class Constructors Methods Properties See Also

The SourceChangeEventArgs<(Of <(T>)>) type exposes the following members.

Constructors

Name | Description
SourceChangeEventArgs<(Of <(T>)>) | Initializes a new instance of the SourceChangeEventArgs<(Of <(T>)>) class.

Methods

Name | Description
Equals | Overloaded.
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Return a hash code for this instance. (Overrides Object..::.GetHashCode()()().)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a string that represents this instance of SourceChangeEventArgs<(Of <(T>)>). (Overrides Object..::.ToString()()().)

Properties

Name | Description
ChangeType | Gets the type of change.
Item | Gets the object that is being changed.
Ordinal | Gets the ordinal position of the collection item that is being changed.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


SourceChangeEventArgs(T) Constructor

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>) Constructor
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Initializes a new instance of the SourceChangeEventArgs<(Of <(T>)>) class.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public SourceChangeEventArgs(
    T item,
    SourceChangeType changeType,
    int ordinal
)
Visual Basic (Declaration)
Public Sub New ( _
    item As T, _
    changeType As SourceChangeType, _
    ordinal As Integer _
)

Parameters

item
Type: T
Changed object.
changeType
Type: C1.LiveLinq..::.SourceChangeType
Type of change.
ordinal
Type: System..::.Int32
Ordinal position of the changed item.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


SourceChangeEventArgs(T) Methods

[image] [image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>) Methods
SourceChangeEventArgs<(Of <(T>)>) Class See Also

The SourceChangeEventArgs<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Overloaded.
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Return a hash code for this instance. (Overrides Object..::.GetHashCode()()().)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a string that represents this instance of SourceChangeEventArgs<(Of <(T>)>). (Overrides Object..::.ToString()()().)

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


Equals Method

[image] [image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.Equals Method
SourceChangeEventArgs<(Of <(T>)>) Class See Also

Overload List

Name | Description
Equals(SourceChangeEventArgs<(Of <(T>)>)) | Determines whether the specified object is equal to the current object.
Equals(Object) | Determines whether the specified object is equal to the current object. (Overrides Object..::.Equals(Object).)

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
SourceChangeEventArgs<(Of <(T>)>) Members
C1.LiveLinq Namespace


Equals Method (SourceChangeEventArgs(T))

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.Equals Method (SourceChangeEventArgs<(Of <(T>)>))
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Determines whether the specified object is equal to the current object.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Equals(
    SourceChangeEventArgs<T> args
)
Visual Basic (Declaration)
Public Function Equals ( _
    args As SourceChangeEventArgs(Of T) _
) As Boolean

Parameters

args
Type: C1.LiveLinq..::.SourceChangeEventArgs <(Of <( T >)>)
The object to compare with the current object.

Return Value

true if the specified object is equal to the current one; otherwise, false.

Implements

IEquatable<(Of <(T>)>)..::.Equals(T)

Remarks

Two SourceChangeEventArgs<(Of <(T>)>) are considered equal if the values of their Item and ChangeType properties are equal.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
Equals Overload
C1.LiveLinq Namespace


Equals Method (Object)

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.Equals Method (Object)
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Determines whether the specified object is equal to the current object.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override bool Equals(
    Object obj
)
Visual Basic (Declaration)
Public Overrides Function Equals ( _
    obj As Object _
) As Boolean

Parameters

obj
Type: System..::.Object
The object to compare with the current object.

Return Value

true if the specified object is equal to the current one; otherwise, false.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
Equals Overload
C1.LiveLinq Namespace


GetHashCode Method

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.GetHashCode Method
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Return a hash code for this instance.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override int GetHashCode()
Visual Basic (Declaration)
Public Overrides Function GetHashCode As Integer

Return Value

A 32-bit signed integer hash code.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


ToString Method

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.ToString Method
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Returns a string that represents this instance of SourceChangeEventArgs<(Of <(T>)>).

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override string ToString()
Visual Basic (Declaration)
Public Overrides Function ToString As String

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


SourceChangeEventArgs(T) Properties

[image] [image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>) Properties
SourceChangeEventArgs<(Of <(T>)>) Class See Also

The SourceChangeEventArgs<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
ChangeType | Gets the type of change.
Item | Gets the object that is being changed.
Ordinal | Gets the ordinal position of the collection item that is being changed.

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


ChangeType Property

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.ChangeType Property
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Gets the type of change.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public SourceChangeType ChangeType { get; private set; }
Visual Basic (Declaration)
Public Property ChangeType As SourceChangeType

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


Item Property

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.Item Property
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Gets the object that is being changed.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public T Item { get; private set; }
Visual Basic (Declaration)
Public Property Item As T

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


Ordinal Property

[image]

.NET Framework Class Library
SourceChangeEventArgs<(Of <(T>)>)..::.Ordinal Property
SourceChangeEventArgs<(Of <(T>)>) Class See Also
Gets the ordinal position of the collection item that is being changed.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int Ordinal { get; private set; }
Visual Basic (Declaration)
Public Property Ordinal As Integer

Remarks

This property can return -1 (ordinal unknown) if the collection cannot provide this information (if SupportsChangingEvent returns false).

See Also

SourceChangeEventArgs<(Of <(T>)>) Class
C1.LiveLinq Namespace


SourceChangeType Enumeration

[image]

.NET Framework Class Library
SourceChangeType Enumeration
See Also
Describes a change occurring in a collection.

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum SourceChangeType
Visual Basic (Declaration)
Public Enumeration SourceChangeType

Members

Member name | Description
Add | An item is added to the collection.
Modify | At least one of the properties of an item has changed its value.
Remove | An item is removed from the collection.
Reset | Multiple items have changed in the collection. Indexes must be rebuilt.

See Also

C1.LiveLinq Namespace


C1.LiveLinq.Listeners Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.Listeners Namespace

Classes

Class | Description
ListenerException | Represents an exception that is thrown by a custom listener code.
PropertyChangeListener<(Of <(T>)>) | Represents a listener object used by LiveLinq to receive notifications of changes to property values in a collection element object.


ListenerException Class

[image]

.NET Framework Class Library
ListenerException Class
Members See Also
Represents an exception that is thrown by a custom listener code.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
[SerializableAttribute]
public class ListenerException : Exception
Visual Basic (Declaration)
<SerializableAttribute> _
Public Class ListenerException _
    Inherits Exception

Inheritance Hierarchy

System..::.Object
System..::.Exception
C1.LiveLinq.Listeners..::.ListenerException

See Also

ListenerException Members
C1.LiveLinq.Listeners Namespace


ListenerException Members

[image] [image]

.NET Framework Class Library
ListenerException Members
ListenerException Class Constructors Methods Properties See Also

The ListenerException type exposes the following members.

Constructors

Name | Description
ListenerException | Overloaded.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

ListenerException Class
C1.LiveLinq.Listeners Namespace


ListenerException Constructor

[image] [image]

.NET Framework Class Library
ListenerException Constructor
ListenerException Class See Also

Overload List

Name | Description
ListenerException()()() | Initializes a new instance of the ListenerException class. This is the default constructor.
ListenerException(String) | Initializes a new instance of the ListenerException class with the specified string.
ListenerException(SerializationInfo, StreamingContext) | Initializes a new instance of the ListenerException class from serialized data.
ListenerException(String, Exception) | Initializes a new instance of the ListenerException class using the specified string and inner exception.

See Also

ListenerException Class
ListenerException Members
C1.LiveLinq.Listeners Namespace


ListenerException Constructor

[image]

.NET Framework Class Library
ListenerException Constructor
ListenerException Class See Also
Initializes a new instance of the ListenerException class. This is the default constructor.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ListenerException()
Visual Basic (Declaration)
Public Sub New

See Also

ListenerException Class
ListenerException Overload
C1.LiveLinq.Listeners Namespace


ListenerException Constructor (String)

[image]

.NET Framework Class Library
ListenerException Constructor (String)
ListenerException Class See Also
Initializes a new instance of the ListenerException class with the specified string.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ListenerException(
    string message
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.

See Also

ListenerException Class
ListenerException Overload
C1.LiveLinq.Listeners Namespace


ListenerException Constructor (SerializationInfo, StreamingContext)

[image]

.NET Framework Class Library
ListenerException Constructor (SerializationInfo, StreamingContext)
ListenerException Class See Also
Initializes a new instance of the ListenerException class from serialized data.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected ListenerException(
    SerializationInfo info,
    StreamingContext context
)
Visual Basic (Declaration)
Protected Sub New ( _
    info As SerializationInfo, _
    context As StreamingContext _
)

Parameters

info
Type: System.Runtime.Serialization..::.SerializationInfo
The object that holds the serialized object data.
context
Type: System.Runtime.Serialization..::.StreamingContext
The contextual information about the source or destination.

See Also

ListenerException Class
ListenerException Overload
C1.LiveLinq.Listeners Namespace


ListenerException Constructor (String, Exception)

[image]

.NET Framework Class Library
ListenerException Constructor (String, Exception)
ListenerException Class See Also
Initializes a new instance of the ListenerException class using the specified string and inner exception.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ListenerException(
    string message,
    Exception inner
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String, _
    inner As Exception _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.
inner
Type: System..::.Exception
Gets the Exception instance that caused the current exception.

See Also

ListenerException Class
ListenerException Overload
C1.LiveLinq.Listeners Namespace


ListenerException Methods

[image] [image]

.NET Framework Class Library
ListenerException Methods
ListenerException Class See Also

The ListenerException type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

See Also

ListenerException Class
C1.LiveLinq.Listeners Namespace


ListenerException Properties

[image] [image]

.NET Framework Class Library
ListenerException Properties
ListenerException Class See Also

The ListenerException type exposes the following members.

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

ListenerException Class
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Class

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Class
Members See Also
Represents a listener object used by LiveLinq to receive notifications of changes to property values in a collection element object.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class PropertyChangeListener<T> : INotifyPropertyChanging,
    INotifyPropertyChanged
Visual Basic (Declaration)
Public MustInherit Class PropertyChangeListener(Of T) _
    Implements INotifyPropertyChanging, INotifyPropertyChanged

Type Parameters

T
The type of the elements in the collection.

Remarks

In most cases, the default listener mechanism performs its function and does not need user intervention. As an advanced functionality, LiveLinq allows the user to customize default listeners. It may be needed in those rare cases when you use IndexedCollection<(Of <(T>)>) with element class T that does not provide property change notifications, and you can't add such notifications, nor by deriving the class from IndexableObject nor by other means, but you have some other way of knowing when property changes occur (maybe you can listen to some events, for example).

Then you can define your own class derived from the base class PropertyChangeListener<T> and pass an object of that class to the IndexedCollection<(Of <(T>)>) constructor.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Listeners..::.PropertyChangeListener<(Of <(T>)>)

See Also

PropertyChangeListener<(Of <(T>)>) Members
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Members

[image] [image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Members
PropertyChangeListener<(Of <(T>)>) Class Constructors Methods Properties Events See Also

The PropertyChangeListener<(Of <(T>)>) type exposes the following members.

Constructors

Name | Description
PropertyChangeListener<(Of <(T>)>) |

Methods

Name | Description
Clear | Stop listening to all, don't listen to any objects.
CreateDefault | Creates the default listener used by LiveLinq to listen to property change notifications in objects of type T.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetListeningProperties | Gets the list of property names for which change notifications are supported.
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event.
OnPropertyChanging | Raises the PropertyChanging event.
StartListening | Start listening to property changes in a particular object.
StopListening | Stop listening to property changes in a particular object.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
SupportsPropertyChangingEvent | Gets a value indicating whether the PropertyChanging event is supported by this listener.

Events

Name | Description
PropertyChanged | Occurs after a property has changed its value.
PropertyChanging | Occurs before a property has changed its value.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Constructor

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Constructor
PropertyChangeListener<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected PropertyChangeListener()
Visual Basic (Declaration)
Protected Sub New

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Methods

[image] [image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Methods
PropertyChangeListener<(Of <(T>)>) Class See Also

The PropertyChangeListener<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Clear | Stop listening to all, don't listen to any objects.
CreateDefault | Creates the default listener used by LiveLinq to listen to property change notifications in objects of type T.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetListeningProperties | Gets the list of property names for which change notifications are supported.
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event.
OnPropertyChanging | Raises the PropertyChanging event.
StartListening | Start listening to property changes in a particular object.
StopListening | Stop listening to property changes in a particular object.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


Clear Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.Clear Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Stop listening to all, don't listen to any objects.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract void Clear()
Visual Basic (Declaration)
Public MustOverride Sub Clear

Remarks

LiveLinq calls this method when a collection is cleared, all objects are removed from it, so it no longer needs to be notified of changes in any of those objects.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


CreateDefault Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.CreateDefault Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Creates the default listener used by LiveLinq to listen to property change notifications in objects of type T.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static PropertyChangeListener<T> CreateDefault()
Visual Basic (Declaration)
Public Shared Function CreateDefault As PropertyChangeListener(Of T)

Return Value

The default listener handling property change notifications.

Remarks

For ADO.NET and XML objects (DataRow, DataRowView, XContainer), their corresponding property change notifications are used.

For objects implementing INotifyPropertyChanged interface, that interface is used (if INotifyPropertyChanging is also implemented, it is also listened to).

If the class is neither of the above, the default listener tries to use two change notification patterns if they are present in the class:

  • events named propertyNameChanged
  • dependency properties of WPF classes

These patterns don't have to exist in the class, it's just a last ditch attempt of the default listener to find a notification mechanism if the standard one is not found.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


GetListeningProperties Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.GetListeningProperties Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Gets the list of property names for which change notifications are supported.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerable<string> GetListeningProperties()
Visual Basic (Declaration)
Public MustOverride Function GetListeningProperties As IEnumerable(Of String)

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


OnPropertyChanged Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.OnPropertyChanged Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Raises the PropertyChanged event.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected virtual void OnPropertyChanged(
    Object sender,
    PropertyChangedEventArgs e
)
Visual Basic (Declaration)
Protected Overridable Sub OnPropertyChanged ( _
    sender As Object, _
    e As PropertyChangedEventArgs _
)

Parameters

sender
Type: System..::.Object
The object where the change has occurred.
e
Type: System.ComponentModel..::.PropertyChangedEventArgs
Event data.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


OnPropertyChanging Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.OnPropertyChanging Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Raises the PropertyChanging event.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected virtual void OnPropertyChanging(
    Object sender,
    PropertyChangingEventArgs e
)
Visual Basic (Declaration)
Protected Overridable Sub OnPropertyChanging ( _
    sender As Object, _
    e As PropertyChangingEventArgs _
)

Parameters

sender
Type: System..::.Object
The object where the change is occurring.
e
Type: System.ComponentModel..::.PropertyChangingEventArgs
Event data.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


StartListening Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.StartListening Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Start listening to property changes in a particular object.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract void StartListening(
    T item
)
Visual Basic (Declaration)
Public MustOverride Sub StartListening ( _
    item As T _
)

Parameters

item
Type: T
The object to listen to.

Remarks

LiveLinq calls this method when a new object is added to a collection, so LiveLinq needs to be notified of changes to property values in that object.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


StopListening Method

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.StopListening Method
PropertyChangeListener<(Of <(T>)>) Class See Also
Stop listening to property changes in a particular object.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract void StopListening(
    T item
)
Visual Basic (Declaration)
Public MustOverride Sub StopListening ( _
    item As T _
)

Parameters

item
Type: T
The object to stop listening to.

Remarks

LiveLinq calls this method when an object is removed from a collection, so LiveLinq no longer needs to be notified of changes to property values in that object.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Properties

[image] [image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Properties
PropertyChangeListener<(Of <(T>)>) Class See Also

The PropertyChangeListener<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
SupportsPropertyChangingEvent | Gets a value indicating whether the PropertyChanging event is supported by this listener.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


SupportsPropertyChangingEvent Property

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.SupportsPropertyChangingEvent Property
PropertyChangeListener<(Of <(T>)>) Class See Also
Gets a value indicating whether the PropertyChanging event is supported by this listener.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract bool SupportsPropertyChangingEvent { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property SupportsPropertyChangingEvent As Boolean

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChangeListener(T) Events

[image] [image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>) Events
PropertyChangeListener<(Of <(T>)>) Class See Also

The PropertyChangeListener<(Of <(T>)>) type exposes the following members.

Events

Name | Description
PropertyChanged | Occurs after a property has changed its value.
PropertyChanging | Occurs before a property has changed its value.

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChanged Event

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.PropertyChanged Event
PropertyChangeListener<(Of <(T>)>) Class See Also
Occurs after a property has changed its value.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual event PropertyChangedEventHandler PropertyChanged
Visual Basic (Declaration)
Public Overridable Event PropertyChanged As PropertyChangedEventHandler

Implements

INotifyPropertyChanged..::.PropertyChanged

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


PropertyChanging Event

[image]

.NET Framework Class Library
PropertyChangeListener<(Of <(T>)>)..::.PropertyChanging Event
PropertyChangeListener<(Of <(T>)>) Class See Also
Occurs before a property has changed its value.

Namespace: C1.LiveLinq.Listeners
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual event PropertyChangingEventHandler PropertyChanging
Visual Basic (Declaration)
Public Overridable Event PropertyChanging As PropertyChangingEventHandler

Implements

INotifyPropertyChanging..::.PropertyChanging

Remarks

This event is optional. Support it when possible, because otherwise LiveLinq will compensate for it by maintaining additional information in memory at some cost to performance.

If this event is not supported, it must be indicated by returning false in the SupportsPropertyChangingEvent property

See Also

PropertyChangeListener<(Of <(T>)>) Class
C1.LiveLinq.Listeners Namespace


C1.LiveLinq.Collections Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.Collections Namespace

Classes

Class | Description
IndexableObject | Base class for collection element classes.
IndexedCollection<(Of <(T>)>) | Data collection class recommended for use in LiveLinq to Objects.


IndexableObject Class

[image]

.NET Framework Class Library
IndexableObject Class
Members See Also
Base class for collection element classes.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class IndexableObject : INotifyPropertyChanged,
    INotifyPropertyChanging
Visual Basic (Declaration)
Public Class IndexableObject _
    Implements INotifyPropertyChanged, INotifyPropertyChanging

Remarks

Using IndexedCollection<(Of <(T>)>) and other collection classes in LiveLinq to Objects, the element class T must implement the property change notification interfaces INotifyPropertyChanging and INotifyPropertyChanged. The easiest way to satisfy this requirement is to derive that class from IndexableObject. Then you can use its methods OnPropertyChanging(String) and OnPropertyChanged(String) to send the required property change notifications. For example, a Customer class can be defined like this:
Copy CodeC#
public class Customer : IndexableObject
{
.....................
    private string _name;
    public string Name
    {
        get {return _name} ;
        set
        {
            OnPropertyChanging("Name");
            _name = value;
            OnPropertyChanged("Name");
        }
    }
.....................
}

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Collections..::.IndexableObject
C1.LiveLinq.LiveViews..::.ViewRow

See Also

IndexableObject Members
C1.LiveLinq.Collections Namespace


IndexableObject Members

[image] [image]

.NET Framework Class Library
IndexableObject Members
IndexableObject Class Constructors Methods Events See Also

The IndexableObject type exposes the following members.

Constructors

Name | Description
IndexableObject | Initializes a new instance of the IndexableObject class.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event.
OnPropertyChanging | Raises the PropertyChanging event.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Events

Name | Description
PropertyChanged | Occurs when a property value changes, after it has been changed.
PropertyChanging | Occurs when a property value is changing, before it has been changed.

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


IndexableObject Constructor

[image]

.NET Framework Class Library
IndexableObject Constructor
IndexableObject Class See Also
Initializes a new instance of the IndexableObject class.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexableObject()
Visual Basic (Declaration)
Public Sub New

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


IndexableObject Methods

[image] [image]

.NET Framework Class Library
IndexableObject Methods
IndexableObject Class See Also

The IndexableObject type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event.
OnPropertyChanging | Raises the PropertyChanging event.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


OnPropertyChanged Method

[image]

.NET Framework Class Library
IndexableObject..::.OnPropertyChanged Method
IndexableObject Class See Also
Raises the PropertyChanged event.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected virtual void OnPropertyChanged(
    string propertyName
)
Visual Basic (Declaration)
Protected Overridable Sub OnPropertyChanged ( _
    propertyName As String _
)

Parameters

propertyName
Type: System..::.String
The name of the property that is changing.

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


OnPropertyChanging Method

[image]

.NET Framework Class Library
IndexableObject..::.OnPropertyChanging Method
IndexableObject Class See Also
Raises the PropertyChanging event.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected virtual void OnPropertyChanging(
    string propertyName
)
Visual Basic (Declaration)
Protected Overridable Sub OnPropertyChanging ( _
    propertyName As String _
)

Parameters

propertyName
Type: System..::.String
The name of the property that is changing.

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


IndexableObject Events

[image] [image]

.NET Framework Class Library
IndexableObject Events
IndexableObject Class See Also

The IndexableObject type exposes the following members.

Events

Name | Description
PropertyChanged | Occurs when a property value changes, after it has been changed.
PropertyChanging | Occurs when a property value is changing, before it has been changed.

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


PropertyChanged Event

[image]

.NET Framework Class Library
IndexableObject..::.PropertyChanged Event
IndexableObject Class See Also
Occurs when a property value changes, after it has been changed.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event PropertyChangedEventHandler PropertyChanged
Visual Basic (Declaration)
Public Event PropertyChanged As PropertyChangedEventHandler

Implements

INotifyPropertyChanged..::.PropertyChanged

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


PropertyChanging Event

[image]

.NET Framework Class Library
IndexableObject..::.PropertyChanging Event
IndexableObject Class See Also
Occurs when a property value is changing, before it has been changed.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event PropertyChangingEventHandler PropertyChanging
Visual Basic (Declaration)
Public Event PropertyChanging As PropertyChangingEventHandler

Implements

INotifyPropertyChanging..::.PropertyChanging

See Also

IndexableObject Class
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Class

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Class
Members See Also
Data collection class recommended for use in LiveLinq to Objects.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class IndexedCollection<T> : Collection<T>,
    IBindingList, IList, ICollection, IList<T>, ICollection<T>,
    INotifyPropertyChanged, IObservableSource<T>, IIndexedSource<T>, IEnumerable<T>, IEnumerable
Visual Basic (Declaration)
Public Class IndexedCollection(Of T) _
    Inherits Collection(Of T) _
    Implements IBindingList, IList, ICollection, IList(Of T),  _
    ICollection(Of T), INotifyPropertyChanged, IObservableSource(Of T), IIndexedSource(Of T),  _
    IEnumerable(Of T), IEnumerable

Type Parameters

T
The type of the elements in the collection.

Remarks

If you don't have preexisting collection classes and need to create your own, the best choice is to use the built-in LiveLinq collection class IndexedCollection<T>. It is specifically optimized for LiveLinq use.

Usually, the element class T must implement the property change notification interfaces INotifyPropertyChanging and INotifyPropertyChanged. The easiest way to implement INotifyPropertyChanging and INotifyPropertyChanged is to derive the element class from IndexableObject.

In rare cases where implementing INotifyPropertyChanged is impossible, a custom PropertyChangeListener<(Of <(T>)>) can be provided instead.

For details, see Using the built-in collection class IndexedCollection(T) (LiveLinq to Objects).

For alternative options in LiveLinq to Objects, see LiveLinq to Objects: IndexedCollection(T) and other collection classes

The IndexedCollection<T> class is not needed in LiveLinq to DataSet and LiveLinq to XML, because in those cases LiveLinq works with collections that already exist in ADO.NET and XML.

Inheritance Hierarchy

System..::.Object
System.Collections.ObjectModel..::.Collection <(Of <(T>)>)
C1.LiveLinq.Collections..::.IndexedCollection<(Of <(T>)>)

See Also

IndexedCollection<(Of <(T>)>) Members
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Members

[image] [image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Members
IndexedCollection<(Of <(T>)>) Class Constructors Methods Properties Events See Also

The IndexedCollection<(Of <(T>)>) type exposes the following members.

Constructors

Name | Description
IndexedCollection<(Of <(T>)>) | Overloaded.

Methods

Name | Description
Add | Adds an object to the end of the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
AddRange | Adds the elements of the specified collection to the end of the IndexedCollection<(Of <(T>)>)
BeginUpdate | Suspends notifications while massive changes are being made to the IndexedCollection<(Of <(T>)>).
Clear | Removes all elements from the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
ClearItems | Removes all elements from the IndexedCollection<(Of <(T>)>) (Overrides Collection<(Of <(T>)>)..::.ClearItems()()().)
Contains | Determines whether an element is in the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
CopyTo | Copies the entire Collection<(Of <(T>)>) to a compatible one-dimensional Array, starting at the specified index of the target array. (Inherited from Collection <(Of <( T >)>).)
EndUpdate | Ends notification suspension started with BeginUpdate()()().
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
IndexOf | Searches for the specified object and returns the zero-based index of the first occurrence within the entire Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
Insert | Inserts an element into the Collection<(Of <(T>)>) at the specified index. (Inherited from Collection <(Of <( T >)>).)
InsertItem | Inserts an element into the IndexedCollection<(Of <(T>)>) at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.InsertItem(Int32, T).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnChanged | Raises the Changed event.
OnChanging | Raises the Changing event.
Remove | Removes the first occurrence of a specific object from the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
RemoveAt | Removes the element at the specified index of the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
RemoveItem | Removes the element of the IndexedCollection<(Of <(T>)>) at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.RemoveItem(Int32).)
SetItem | Replaces the element at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.SetItem(Int32, T).)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the number of elements actually contained in the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
CreateNew | Gets or sets a delegate that is used to create new items. If it is null, a public parameterless constructor of type T is used.
Indexes | The collection of indexes for this IndexedCollection<(Of <(T>)>)
Item | Gets or sets the element at the specified index. (Inherited from Collection <(Of <( T >)>).)
Items | Gets a IList<(Of <(T>)>) wrapper around the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)

Events

Name | Description
Changed | Occurs after the collection has changed.
Changing | Occurs before the collection has changed.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Constructor

[image] [image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Constructor
IndexedCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
IndexedCollection<(Of <(T>)>)()()() | Initializes a new instance of the IndexedCollection<(Of <(T>)>) class.
IndexedCollection<(Of <(T>)>)(IList<(Of <(T>)>)) | Initializes a new instance of the IndexedCollection<(Of <(T>)>) class that contains elements copied from the specified list.
IndexedCollection<(Of <(T>)>)(IList<(Of <(T>)>), PropertyChangeListener<(Of <(T>)>)) | Initializes a new instance of the IndexedCollection<(Of <(T>)>) class that contains elements copied from the specified list, and provides a custom PropertyChangeListener<(Of <(T>)>).

See Also

IndexedCollection<(Of <(T>)>) Class
IndexedCollection<(Of <(T>)>) Members
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Constructor

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Constructor
IndexedCollection<(Of <(T>)>) Class See Also
Initializes a new instance of the IndexedCollection<(Of <(T>)>) class.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexedCollection()
Visual Basic (Declaration)
Public Sub New

See Also

IndexedCollection<(Of <(T>)>) Class
IndexedCollection<(Of <(T>)>) Overload
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Constructor (IList(T))

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Constructor (IList<(Of <(T>)>))
IndexedCollection<(Of <(T>)>) Class See Also
Initializes a new instance of the IndexedCollection<(Of <(T>)>) class that contains elements copied from the specified list.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexedCollection(
    IList<T> list
)
Visual Basic (Declaration)
Public Sub New ( _
    list As IList(Of T) _
)

Parameters

list
Type: System.Collections.Generic..::.IList <(Of <( T >)>)
The collection whose elements are copied to the new instance.

See Also

IndexedCollection<(Of <(T>)>) Class
IndexedCollection<(Of <(T>)>) Overload
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Constructor (IList(T), PropertyChangeListener(T))

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Constructor (IList<(Of <(T>)>), PropertyChangeListener<(Of <(T>)>))
IndexedCollection<(Of <(T>)>) Class See Also
Initializes a new instance of the IndexedCollection<(Of <(T>)>) class that contains elements copied from the specified list, and provides a custom PropertyChangeListener<(Of <(T>)>).

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexedCollection(
    IList<T> list,
    PropertyChangeListener<T> itemPropertyChangeListener
)
Visual Basic (Declaration)
Public Sub New ( _
    list As IList(Of T), _
    itemPropertyChangeListener As PropertyChangeListener(Of T) _
)

Parameters

list
Type: System.Collections.Generic..::.IList <(Of <( T >)>)
The collection whose elements are copied to the new instance.
itemPropertyChangeListener
Type: C1.LiveLinq.Listeners..::.PropertyChangeListener <(Of <( T >)>)
The custom PropertyChangeListener<(Of <(T>)>) to use with the collection.

Remarks

This constructor is intended for the rare cases where implementing INotifyPropertyChanged in the class of the elements of the collection is impossible

See Also

IndexedCollection<(Of <(T>)>) Class
IndexedCollection<(Of <(T>)>) Overload
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Methods

[image] [image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Methods
IndexedCollection<(Of <(T>)>) Class See Also

The IndexedCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Adds an object to the end of the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
AddRange | Adds the elements of the specified collection to the end of the IndexedCollection<(Of <(T>)>)
BeginUpdate | Suspends notifications while massive changes are being made to the IndexedCollection<(Of <(T>)>).
Clear | Removes all elements from the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
ClearItems | Removes all elements from the IndexedCollection<(Of <(T>)>) (Overrides Collection<(Of <(T>)>)..::.ClearItems()()().)
Contains | Determines whether an element is in the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
CopyTo | Copies the entire Collection<(Of <(T>)>) to a compatible one-dimensional Array, starting at the specified index of the target array. (Inherited from Collection <(Of <( T >)>).)
EndUpdate | Ends notification suspension started with BeginUpdate()()().
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
IndexOf | Searches for the specified object and returns the zero-based index of the first occurrence within the entire Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
Insert | Inserts an element into the Collection<(Of <(T>)>) at the specified index. (Inherited from Collection <(Of <( T >)>).)
InsertItem | Inserts an element into the IndexedCollection<(Of <(T>)>) at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.InsertItem(Int32, T).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnChanged | Raises the Changed event.
OnChanging | Raises the Changing event.
Remove | Removes the first occurrence of a specific object from the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
RemoveAt | Removes the element at the specified index of the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
RemoveItem | Removes the element of the IndexedCollection<(Of <(T>)>) at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.RemoveItem(Int32).)
SetItem | Replaces the element at the specified ordinal position. (Overrides Collection<(Of <(T>)>)..::.SetItem(Int32, T).)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


AddRange Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.AddRange Method
IndexedCollection<(Of <(T>)>) Class See Also
Adds the elements of the specified collection to the end of the IndexedCollection<(Of <(T>)>)

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void AddRange(
    IEnumerable<T> items
)
Visual Basic (Declaration)
Public Sub AddRange ( _
    items As IEnumerable(Of T) _
)

Parameters

items
Type: System.Collections.Generic..::.IEnumerable <(Of <( T >)>)
The collection whose elements should be added to the end of the IndexedCollection<(Of <(T>)>)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


BeginUpdate Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.BeginUpdate Method
IndexedCollection<(Of <(T>)>) Class See Also
Suspends notifications while massive changes are being made to the IndexedCollection<(Of <(T>)>).

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void BeginUpdate()
Visual Basic (Declaration)
Public Sub BeginUpdate

Remarks

This method must be followed by EndUpdate()()().

Use this method when you already have indexes built over the IndexedCollection<(Of <(T>)>) or live views based on it, and you need to re-populate this IndexedCollection<(Of <(T>)>) or perform other massive changes to items of this collection. Without this method, every single change you make causes LiveLinq to perform necessary operations for maintaining your indexes and live views dependent on this collection. In case of massive changes, this can be slower than to wait until the massive changes are done and rebuild the indexes and live views.

Between BeginUpdate and EndUpdate()()() calls, indexes, live views, bound controls and other change notification listeners are not updated, they don't receive change notifications.

When EndUpdate()()() is called, a SourceChangeType.Modify or SourceChangeType.Reset notification is sent, depending on whether the change affected a single item or multiple items of the collection. Even when you change a single item, it may make sense to enclose your changes in BeginUpdate/EndUpdate if you change multiple properties of the item. In that case a SourceChangeType.Modify notification is sent. If more than one item was changed, a SourceChangeType.Reset notification is sent, meaning all indexes, live views and other collections dependent on this data table must be rebuilt from scratch.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


ClearItems Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.ClearItems Method
IndexedCollection<(Of <(T>)>) Class See Also
Removes all elements from the IndexedCollection<(Of <(T>)>)

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected override void ClearItems()
Visual Basic (Declaration)
Protected Overrides Sub ClearItems

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


EndUpdate Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.EndUpdate Method
IndexedCollection<(Of <(T>)>) Class See Also
Ends notification suspension started with BeginUpdate()()().

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void EndUpdate()
Visual Basic (Declaration)
Public Sub EndUpdate

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


InsertItem Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.InsertItem Method
IndexedCollection<(Of <(T>)>) Class See Also
Inserts an element into the IndexedCollection<(Of <(T>)>) at the specified ordinal position.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected override void InsertItem(
    int ordinal,
    T item
)
Visual Basic (Declaration)
Protected Overrides Sub InsertItem ( _
    ordinal As Integer, _
    item As T _
)

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal at which the item must be inserted.
item
Type: T
The object to insert.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


OnChanged Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.OnChanged Method
IndexedCollection<(Of <(T>)>) Class See Also
Raises the Changed event.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected void OnChanged(
    SourceChangeEventArgs<T> e
)
Visual Basic (Declaration)
Protected Sub OnChanged ( _
    e As SourceChangeEventArgs(Of T) _
)

Parameters

e
Type: C1.LiveLinq..::.SourceChangeEventArgs <(Of <( T >)>)
Event data.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


OnChanging Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.OnChanging Method
IndexedCollection<(Of <(T>)>) Class See Also
Raises the Changing event.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected virtual void OnChanging(
    SourceChangeEventArgs<T> e
)
Visual Basic (Declaration)
Protected Overridable Sub OnChanging ( _
    e As SourceChangeEventArgs(Of T) _
)

Parameters

e
Type: C1.LiveLinq..::.SourceChangeEventArgs <(Of <( T >)>)
Event data.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


RemoveItem Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.RemoveItem Method
IndexedCollection<(Of <(T>)>) Class See Also
Removes the element of the IndexedCollection<(Of <(T>)>) at the specified ordinal position.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected override void RemoveItem(
    int ordinal
)
Visual Basic (Declaration)
Protected Overrides Sub RemoveItem ( _
    ordinal As Integer _
)

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal of the element to remove.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


SetItem Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.SetItem Method
IndexedCollection<(Of <(T>)>) Class See Also
Replaces the element at the specified ordinal position.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected override void SetItem(
    int ordinal,
    T newItem
)
Visual Basic (Declaration)
Protected Overrides Sub SetItem ( _
    ordinal As Integer, _
    newItem As T _
)

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal of the element to replace.
newItem
Type: T
The new value for the element at the specified ordinal. The value can be null for reference types.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Properties

[image] [image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Properties
IndexedCollection<(Of <(T>)>) Class See Also

The IndexedCollection<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the number of elements actually contained in the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)
CreateNew | Gets or sets a delegate that is used to create new items. If it is null, a public parameterless constructor of type T is used.
Indexes | The collection of indexes for this IndexedCollection<(Of <(T>)>)
Item | Gets or sets the element at the specified index. (Inherited from Collection <(Of <( T >)>).)
Items | Gets a IList<(Of <(T>)>) wrapper around the Collection<(Of <(T>)>). (Inherited from Collection <(Of <( T >)>).)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


CreateNew Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.CreateNew Property
IndexedCollection<(Of <(T>)>) Class See Also
Gets or sets a delegate that is used to create new items. If it is null, a public parameterless constructor of type T is used.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Func<T> CreateNew { get; set; }
Visual Basic (Declaration)
Public Property CreateNew As Func(Of T)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


Indexes Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.Indexes Property
IndexedCollection<(Of <(T>)>) Class See Also
The collection of indexes for this IndexedCollection<(Of <(T>)>)

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexCollection<T> Indexes { get; }
Visual Basic (Declaration)
Public ReadOnly Property Indexes As IndexCollection(Of T)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IndexedCollection(T) Events

[image] [image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>) Events
IndexedCollection<(Of <(T>)>) Class See Also

The IndexedCollection<(Of <(T>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after the collection has changed.
Changing | Occurs before the collection has changed.

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


Changed Event

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.Changed Event
IndexedCollection<(Of <(T>)>) Class See Also
Occurs after the collection has changed.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<T>> Changed
Visual Basic (Declaration)
Public Event Changed As EventHandler(Of SourceChangeEventArgs(Of T))

Implements

IObservableSource<(Of <(T>)>)..::.Changed

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


Changing Event

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.Changing Event
IndexedCollection<(Of <(T>)>) Class See Also
Occurs before the collection has changed.

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<T>> Changing
Visual Basic (Declaration)
Public Event Changing As EventHandler(Of SourceChangeEventArgs(Of T))

Implements

IObservableSource<(Of <(T>)>)..::.Changing

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


C1.LiveLinq.Indexing Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.Indexing Namespace

Classes

Class | Description
Index<(Of <(T>)>) | Base class for the Index<(Of <(T, TKey>)>) class.
Index<(Of <(T, TKey>)>) | Indexes a collection by an expression (typically, by a field), providing fast access to items having particular values (or range of values) of that expression.
IndexCollection<(Of <(T>)>) | Represents a collection of indexes attached to an indexed collection.
IndexDefinition<(Of <(T>)>) | Contains common part of the Index and Subindex classes.
IndexingAlgorithm | Defines the kind of an index, the algorithm used by that index. Currently, the RedBlackTree algorithm is always used.
IndexingException | Represents an exception that is thrown when errors are generated using LiveLinq components.
ScannerCollection<(Of <(T>)>) | Represents a collection of indexes or subindexes.
Subindex<(Of <(T>)>) | Base class for the Subindex<(Of <(T, TKey>)>) class.
Subindex<(Of <(T, TKey>)>) | Defines a subindex, an index definition subordinate to another index definition, its parent.
SubindexCollection<(Of <(T>)>) | Represents a collection of subindexes attached to an IndexDefinition<(Of <(T>)>).

Interfaces

Interface | Description
IIndexedSource<(Of <(T>)>) | Represents an indexed collection.


IIndexedSource(T) Interface

[image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>) Interface
Members See Also
Represents an indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public interface IIndexedSource<T> : IEnumerable<T>,
    IEnumerable
Visual Basic (Declaration)
Public Interface IIndexedSource(Of T) _
    Implements IEnumerable(Of T), IEnumerable

Type Parameters

T
The type of the elements of the collection.

Remarks

An indexed collection has a collection of indexes, ScannerCollection<(Of <(T>)>) that are maintained up-to-date on every change made to the collection.

This interface is implemented by all main LiveLinq collection classes: IndexedCollection<(Of <(T>)>), IndexedDataTable<(Of <(TRow>)>), View<(Of <(T>)>).

You need to implement this interface only if you want to define your own indexable collection classes and then only if they don't inherit from IndexedCollection<(Of <(T>)>), see LiveLinq to Objects: IndexedCollection(T) and other collection classes.

See Also

IIndexedSource<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


IIndexedSource(T) Members

[image] [image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>) Members
IIndexedSource<(Of <(T>)>) Interface Methods Properties See Also

The IIndexedSource<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
GetEnumerator | Overloaded.

Properties

Name | Description
Indexes | Gets the collection of indexes attached to this collection.

See Also

IIndexedSource<(Of <(T>)>) Interface
C1.LiveLinq.Indexing Namespace


IIndexedSource(T) Methods

[image] [image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>) Methods
IIndexedSource<(Of <(T>)>) Interface See Also

Methods

Name | Description
GetEnumerator | Overloaded.

See Also

IIndexedSource<(Of <(T>)>) Interface
C1.LiveLinq.Indexing Namespace


GetEnumerator Method

[image] [image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>)..::.GetEnumerator Method
IIndexedSource<(Of <(T>)>) Interface See Also

Overload List

Name | Description
GetEnumerator()()() | Returns an enumerator that iterates through the collection. (Inherited from IEnumerable <(Of <(T>)>).)
GetEnumerator()()() | Returns an enumerator that iterates through a collection. (Inherited from IEnumerable.)

See Also

IIndexedSource<(Of <(T>)>) Interface
IIndexedSource<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


IIndexedSource(T) Properties

[image] [image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>) Properties
IIndexedSource<(Of <(T>)>) Interface See Also

The IIndexedSource<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Indexes | Gets the collection of indexes attached to this collection.

See Also

IIndexedSource<(Of <(T>)>) Interface
C1.LiveLinq.Indexing Namespace


Indexes Property

[image]

.NET Framework Class Library
IIndexedSource<(Of <(T>)>)..::.Indexes Property
IIndexedSource<(Of <(T>)>) Interface See Also
Gets the collection of indexes attached to this collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<T> Indexes { get; }
Visual Basic (Declaration)
ReadOnly Property Indexes As ScannerCollection(Of T)

Field Value

A collection of indexes attached to this collection. If this is an independent collection, not the result of a LiveLinq indexing search, then its Indexes collection contains Index<(Of <(T>)>) objects. Otherwise, that is, if it is the result of an indexing search operation such as Index.Find and others, it contains subindexes implementing IIndexScanner<(Of <(T>)>).

See Also

IIndexedSource<(Of <(T>)>) Interface
C1.LiveLinq.Indexing Namespace


Index(T) Class

[image]

.NET Framework Class Library
Index<(Of <(T>)>) Class
Members See Also
Base class for the Index<(Of <(T, TKey>)>) class.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class Index<T> : IndexDefinition<T>,
    IIndexScanner<T>
Visual Basic (Declaration)
Public MustInherit Class Index(Of T) _
    Inherits IndexDefinition(Of T) _
    Implements IIndexScanner(Of T)

Type Parameters

T
The type of the elements of the collection to index.

Remarks

You don't typically use the Index<T> class directly. It provides functionality of the Index<(Of <(T, TKey>)>) class that does not depend on the index key type. The base class Index<T> is needed only if the index key type is not known, usually in general-purpose code intended for reuse with different key types.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexDefinition <(Of <(T>)>)
C1.LiveLinq.Indexing..::.Index<(Of <(T>)>)
C1.LiveLinq.Indexing..::.Index<(Of <(T, TKey>)>)

See Also

Index<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace
C1.LiveLinq.Indexing..::.Index<(Of <(T, TKey>)>)


Index(T) Members

[image] [image]

.NET Framework Class Library
Index<(Of <(T>)>) Members
Index<(Of <(T>)>) Class Methods Properties See Also

The Index<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
ContainsKey | Returns a value that indicates whether the indexed collection contains an item with the given key value. Implements IIndexScanner(T).ContainsKey(object)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Finds items with the specified key value. Implements IIndexScanner(T).Find(object)
FindBetween | Finds items with key values in the interval between the specified values. Implements IIndexScanner(T).FindBetween(object,bool,object,bool,Order)
FindGreater | Finds items with keys greater than the specified value. Implements IIndexScanner(T).FindGreater(object,bool,Order)
FindKeys | Finds items containing any of the specified key values. Implements FindKeys(IEnumerable,Order)
FindLess | Finds items with keys less than the specified value. Implements IIndexScanner(T).FindLess(object,bool,Order)
FindStartingWith | Finds items with string key values starting with the specified string. Implements IIndexScanner(T).FindStartingWith(string,Func(string, bool),Order)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupJoin | Overloaded.
Join | Overloaded.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
ItemCount | Gets the number of elements in the indexed collection.
KeyCount | Gets the number of distinct key values in all items of this collection.
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Index(T) Methods

[image] [image]

.NET Framework Class Library
Index<(Of <(T>)>) Methods
Index<(Of <(T>)>) Class See Also

The Index<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
ContainsKey | Returns a value that indicates whether the indexed collection contains an item with the given key value. Implements IIndexScanner(T).ContainsKey(object)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Finds items with the specified key value. Implements IIndexScanner(T).Find(object)
FindBetween | Finds items with key values in the interval between the specified values. Implements IIndexScanner(T).FindBetween(object,bool,object,bool,Order)
FindGreater | Finds items with keys greater than the specified value. Implements IIndexScanner(T).FindGreater(object,bool,Order)
FindKeys | Finds items containing any of the specified key values. Implements FindKeys(IEnumerable,Order)
FindLess | Finds items with keys less than the specified value. Implements IIndexScanner(T).FindLess(object,bool,Order)
FindStartingWith | Finds items with string key values starting with the specified string. Implements IIndexScanner(T).FindStartingWith(string,Func(string, bool),Order)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupJoin | Overloaded.
Join | Overloaded.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ContainsKey Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.ContainsKey Method
Index<(Of <(T>)>) Class See Also

Returns a value that indicates whether the indexed collection contains an item with the given key value.

Implements IIndexScanner(T).ContainsKey(object)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool ContainsKey(
    Object key
)
Visual Basic (Declaration)
Public Function ContainsKey ( _
    key As Object _
) As Boolean

Parameters

key
Type: System..::.Object
The key value to search for.

Return Value

true if the indexed collection contains an element with the specified key value; otherwise, false.

Implements

IIndexScanner<(Of <(T>)>)..::.ContainsKey(Object)

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Find Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.Find Method
Index<(Of <(T>)>) Class See Also

Finds items with the specified key value.

Implements IIndexScanner(T).Find(object)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T> Find(
    Object key
)
Visual Basic (Declaration)
Public Function Find ( _
    key As Object _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
The key value to search for.

Return Value

An object enumerating items having the specified key value.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


FindBetween Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.FindBetween Method
Index<(Of <(T>)>) Class See Also

Finds items with key values in the interval between the specified values.

Implements IIndexScanner(T).FindBetween(object,bool,object,bool,Order)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T> FindBetween(
    Object min,
    bool minInclusive,
    Object max,
    bool maxInclusive,
    Order order
)
Visual Basic (Declaration)
Public Function FindBetween ( _
    min As Object, _
    minInclusive As Boolean, _
    max As Object, _
    maxInclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

min
Type: System..::.Object
Minimum key value to search for.
minInclusive
Type: System..::.Boolean
If true, the result includes items with the minimum key value.
max
Type: System..::.Object
Maximum key value to search for.
maxInclusive
Type: System..::.Boolean
If true, the result includes items with the maximum key value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items with key values within the specified limits.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


FindGreater Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.FindGreater Method
Index<(Of <(T>)>) Class See Also

Finds items with keys greater than the specified value.

Implements IIndexScanner(T).FindGreater(object,bool,Order)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T> FindGreater(
    Object key,
    bool inclusive,
    Order order
)
Visual Basic (Declaration)
Public Function FindGreater ( _
    key As Object, _
    inclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
Minimum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly greater than the specified value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are greater than the specified value.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


FindKeys Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.FindKeys Method
Index<(Of <(T>)>) Class See Also

Finds items containing any of the specified key values.

Implements FindKeys(IEnumerable,Order)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T> FindKeys(
    IEnumerable keys,
    Order order
)
Visual Basic (Declaration)
Public Function FindKeys ( _
    keys As IEnumerable, _
    order As Order _
) As IndexQuery(Of T)

Parameters

keys
Type: System.Collections..::.IEnumerable
The key values to search for.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values belong to the specified key value collection.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


FindLess Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.FindLess Method
Index<(Of <(T>)>) Class See Also

Finds items with keys less than the specified value.

Implements IIndexScanner(T).FindLess(object,bool,Order)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T> FindLess(
    Object key,
    bool inclusive,
    Order order
)
Visual Basic (Declaration)
Public Function FindLess ( _
    key As Object, _
    inclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
Maximum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly less than the specified value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are less than the specified value.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


FindStartingWith Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.FindStartingWith Method
Index<(Of <(T>)>) Class See Also

Finds items with string key values starting with the specified string.

Implements IIndexScanner(T).FindStartingWith(string,Func(string, bool),Order)

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexQuery<T, string> FindStartingWith(
    string value,
    Func<string, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Public Function FindStartingWith ( _
    value As String, _
    keyPredicate As Func(Of String, Boolean), _
    order As Order _
) As IndexQuery(Of T, String)

Parameters

value
Type: System..::.String
The string to search for as the beginning of key value strings.
keyPredicate
Type: System..::.Func <(Of <( String, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are strings that have a beginning matching the specified string and satisfy the optional condition.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


GroupJoin Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.GroupJoin Method
Index<(Of <(T>)>) Class See Also

Overload List

Name | Description
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection. Implements IIndexScanner(T).GroupJoin
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence. Implements IIndexScanner(T).GroupJoin
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection. Implements IIndexScanner(T).GroupJoin

See Also

Index<(Of <(T>)>) Class
Index<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IIndexScanner(T2), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
Index<(Of <(T>)>) Class See Also

Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.

Implements IIndexScanner(T).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IIndexScanner<T2> source,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IIndexScanner(Of T2), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2>)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second collection joined to it.

Remarks

Matching of two elements is performed by matching their keys.

See Also

Index<(Of <(T>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(IEnumerable(T), T2, TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order)
Index<(Of <(T>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.

Implements IIndexScanner(T).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<IEnumerable<T>, T2, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of IEnumerable(Of T), T2, TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( IEnumerable <(Of <( T >)>), T2, TResult>)>)>)>)
A function to create a result element from an element of the second sequence and the collection of matching elements from this collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of the second collection and the corresponding enumeration of the items of this collection joined to it.

See Also

Index<(Of <(T>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
Index<(Of <(T>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

Implements IIndexScanner(T).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second sequence.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second sequence joined to it.

See Also

Index<(Of <(T>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


Join Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.Join Method
Index<(Of <(T>)>) Class See Also

Overload List

Name | Description
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys. Implements IIndexScanner(T).Join
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys. Implements IIndexScanner(T).Join

See Also

Index<(Of <(T>)>) Class
Index<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Join(T2, TResult) Method (IIndexScanner(T2), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.Join<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
Index<(Of <(T>)>) Class See Also

Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.

Implements IIndexScanner(T).Join

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> Join<T2, TResult>(
    IIndexScanner<T2> source,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function Join(Of T2, TResult) ( _
    source As IIndexScanner(Of T2), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2>)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

Remarks

Matching of two elements is performed by matching their keys.

See Also

Index<(Of <(T>)>) Class
Join Overload
C1.LiveLinq.Indexing Namespace


Join(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.Join<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
Index<(Of <(T>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

Implements IIndexScanner(T).Join

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> Join<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function Join(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from a second sequence's item the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

See Also

Index<(Of <(T>)>) Class
Join Overload
C1.LiveLinq.Indexing Namespace


Index(T) Properties

[image] [image]

.NET Framework Class Library
Index<(Of <(T>)>) Properties
Index<(Of <(T>)>) Class See Also

The Index<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
ItemCount | Gets the number of elements in the indexed collection.
KeyCount | Gets the number of distinct key values in all items of this collection.
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ItemCount Property

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.ItemCount Property
Index<(Of <(T>)>) Class See Also
Gets the number of elements in the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int ItemCount { get; }
Visual Basic (Declaration)
Public ReadOnly Property ItemCount As Integer

Field Value

The number of elements in the indexed collection.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


KeyCount Property

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.KeyCount Property
Index<(Of <(T>)>) Class See Also
Gets the number of distinct key values in all items of this collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract int KeyCount { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property KeyCount As Integer

Field Value

Number of distinct key values in the collection.

Implements

IIndexScanner<(Of <(T>)>)..::.KeyCount

Remarks

This number is not the same as ItemCount, unless the index key is a unique key of that collection, see KeyIsUnique.

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Index(T, TKey) Class

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>) Class
Members See Also
Indexes a collection by an expression (typically, by a field), providing fast access to items having particular values (or range of values) of that expression.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class Index<T, TKey> : Index<T>,
    IIndexScanner<T, TKey>, IIndexScanner<T>
Visual Basic (Declaration)
Public MustInherit Class Index(Of T, TKey) _
    Inherits Index(Of T) _
    Implements IIndexScanner(Of T, TKey), IIndexScanner(Of T)

Type Parameters

T
The type of the elements of the collection to index.
TKey
The type of the index key.

Remarks

Indexes can be created and added to a collection explicitly in code by calling IndexCollection.Add, or their creation can be enforced in LINQ queries by using the Indexed hint.

In LINQ queries, indexes are used for optimizing query performance if that is specified with an Indexed hint. Usually, hints are not required, because LiveLinq can automatically determine that an index can be used to speedup a query, but using hints helps to ensure this optimization.

Indexes can also be used programmatically in code, without LINQ syntax, by using the methods of the IIndexScanner<(Of <(T, TKey>)>) interface that is implemented by the Index<(Of <(T, TKey>)>) class. For example, you can call such methods as Find directly for an Index<(Of <(T, TKey>)>) object.

It must be kept in mind that every index you create introduces a trade-off: it can dramatically speed up searches, but it consumes memory and adds some (usually, small) overhead every time the indexed collection (or any of the items, its elements) is modified. This is why indexes should generally be kept only while you need them for queries. To delete an index, use IndexCollection.Remove.

An index can have subindexes, see Subindex<(Of <(T, TKey>)>). Subindexes are optional, not required for any indexing tasks, but can provide additional optimization and help minimize memory requirements when a collection is indexed by multiple keys. In presence of subindexes, an index is the root level of a tree of subindexes.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexDefinition <(Of <(T>)>)
C1.LiveLinq.Indexing..::.Index <(Of <(T>)>)
C1.LiveLinq.Indexing..::.Index<(Of <(T, TKey>)>)

See Also

Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


Index(T, TKey) Members

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>) Members
Index<(Of <(T, TKey>)>) Class Methods Properties See Also

The Index<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
All | Gets all items in the indexed collection.
ContainsKey | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
FindBetween | Overloaded.
FindGreater | Overloaded.
FindKeys | Overloaded.
FindLess | Overloaded.
FindSingle | Finds the only item with the specified key value and throws an exception if there is not exactly one item with that key value.
FindStartingWith | Finds items with string key values starting with the specified string. Implements IIndexScanner(T).FindStartingWith(string,Func(string, bool),Order) (Inherited from Index<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupJoin | Overloaded.
Join | Overloaded.
Keys | Gets distinct key values in all items of the indexed collection.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
ItemCount | Gets the number of elements in the indexed collection. (Inherited from Index<(Of <(T>)>).)
KeyCount | Gets the number of distinct key values in all items of this collection. (Inherited from Index<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


Index(T, TKey) Methods

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>) Methods
Index<(Of <(T, TKey>)>) Class See Also

The Index<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
All | Gets all items in the indexed collection.
ContainsKey | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
FindBetween | Overloaded.
FindGreater | Overloaded.
FindKeys | Overloaded.
FindLess | Overloaded.
FindSingle | Finds the only item with the specified key value and throws an exception if there is not exactly one item with that key value.
FindStartingWith | Finds items with string key values starting with the specified string. Implements IIndexScanner(T).FindStartingWith(string,Func(string, bool),Order) (Inherited from Index<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupJoin | Overloaded.
Join | Overloaded.
Keys | Gets distinct key values in all items of the indexed collection.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


All Method

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.All Method
Index<(Of <(T, TKey>)>) Class See Also
Gets all items in the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IndexQuery<T, TKey> All(
    Order order
)
Visual Basic (Declaration)
Public MustOverride Function All ( _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

order
Type: C1.LiveLinq..::.Order
Specifies the order of the key values to sort the result.

Return Value

An object enumerating all items of the collection in the specified order of their key values.

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


ContainsKey Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.ContainsKey Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
ContainsKey(Object) | Returns a value that indicates whether the indexed collection contains an item with the given key value. Implements IIndexScanner(T).ContainsKey(object) (Inherited from Index<(Of <(T>)>).)
ContainsKey(TKey) | Returns a value that indicates whether the collection contains an item with the given key value.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


ContainsKey Method (TKey)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.ContainsKey Method (TKey)
Index<(Of <(T, TKey>)>) Class See Also
Returns a value that indicates whether the collection contains an item with the given key value.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract bool ContainsKey(
    TKey key
)
Visual Basic (Declaration)
Public MustOverride Function ContainsKey ( _
    key As TKey _
) As Boolean

Parameters

key
Type: TKey
The key value to search for.

Return Value

true if the collection contains an element with the specified key value; otherwise, false.

Implements

IIndexScanner<(Of <(T, TKey>)>)..::.ContainsKey(TKey)

See Also

Index<(Of <(T, TKey>)>) Class
ContainsKey Overload
C1.LiveLinq.Indexing Namespace


Find Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Find Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
Find(Object) | Finds items with the specified key value. Implements IIndexScanner(T).Find(object) (Inherited from Index<(Of <(T>)>).)
Find(TKey) | Finds items with the specified key value.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


Find Method (TKey)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Find Method (TKey)
Index<(Of <(T, TKey>)>) Class See Also
Finds items with the specified key value.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IndexQuery<T, TKey> Find(
    TKey key
)
Visual Basic (Declaration)
Public MustOverride Function Find ( _
    key As TKey _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
The key value to search for.

Return Value

An object enumerating items having the specified key value.

See Also

Index<(Of <(T, TKey>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


FindBetween Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindBetween Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
FindBetween(Object, Boolean, Object, Boolean, Order) | Finds items with key values in the interval between the specified values. Implements IIndexScanner(T).FindBetween(object,bool,object,bool,Order) (Inherited from Index<(Of <(T>)>).)
FindBetween(TKey, Boolean, TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with key values in the interval between the specified values.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


FindBetween Method (TKey, Boolean, TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindBetween Method (TKey, Boolean, TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also
Finds items with key values in the interval between the specified values.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual IndexQuery<T, TKey> FindBetween(
    TKey min,
    bool minInclusive,
    TKey max,
    bool maxInclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Public Overridable Function FindBetween ( _
    min As TKey, _
    minInclusive As Boolean, _
    max As TKey, _
    maxInclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

min
Type: TKey
Minimum key value to search for.
minInclusive
Type: System..::.Boolean
If true, the result includes items with the minimum key value.
max
Type: TKey
Maximum key value to search for.
maxInclusive
Type: System..::.Boolean
If true, the result includes items with the maximum key value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items with key values within the specified limits.

See Also

Index<(Of <(T, TKey>)>) Class
FindBetween Overload
C1.LiveLinq.Indexing Namespace


FindGreater Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindGreater Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
FindGreater(Object, Boolean, Order) | Finds items with keys greater than the specified value. Implements IIndexScanner(T).FindGreater(object,bool,Order) (Inherited from Index<(Of <(T>)>).)
FindGreater(TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with keys greater than the specified value.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


FindGreater Method (TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindGreater Method (TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also
Finds items with keys greater than the specified value.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual IndexQuery<T, TKey> FindGreater(
    TKey key,
    bool inclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Public Overridable Function FindGreater ( _
    key As TKey, _
    inclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
Minimum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly greater than the specified value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are greater than the specified value.

See Also

Index<(Of <(T, TKey>)>) Class
FindGreater Overload
C1.LiveLinq.Indexing Namespace


FindKeys Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindKeys Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
FindKeys(IEnumerable, Order) | Finds items containing any of the specified key values. Implements FindKeys(IEnumerable,Order) (Inherited from Index<(Of <(T>)>).)
FindKeys(IEnumerable<(Of <(TKey>)>), Order) | Finds items containing any of the specified key values.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


FindKeys Method (IEnumerable(TKey), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindKeys Method (IEnumerable<(Of <(TKey>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also
Finds items containing any of the specified key values.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IndexQuery<T, TKey> FindKeys(
    IEnumerable<TKey> keys,
    Order order
)
Visual Basic (Declaration)
Public MustOverride Function FindKeys ( _
    keys As IEnumerable(Of TKey), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

keys
Type: System.Collections.Generic..::.IEnumerable <(Of <( TKey >)>)
The key values to search for.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values belong to the specified key value collection.

See Also

Index<(Of <(T, TKey>)>) Class
FindKeys Overload
C1.LiveLinq.Indexing Namespace


FindLess Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindLess Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
FindLess(Object, Boolean, Order) | Finds items with keys less than the specified value. Implements IIndexScanner(T).FindLess(object,bool,Order) (Inherited from Index<(Of <(T>)>).)
FindLess(TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with keys less than the specified value.

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


FindLess Method (TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindLess Method (TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also
Finds items with keys less than the specified value.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual IndexQuery<T, TKey> FindLess(
    TKey key,
    bool inclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Public Overridable Function FindLess ( _
    key As TKey, _
    inclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
Maximum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly less than the specified value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are less than the specified value.

See Also

Index<(Of <(T, TKey>)>) Class
FindLess Overload
C1.LiveLinq.Indexing Namespace


FindSingle Method

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.FindSingle Method
Index<(Of <(T, TKey>)>) Class See Also
Finds the only item with the specified key value and throws an exception if there is not exactly one item with that key value.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual T FindSingle(
    TKey key
)
Visual Basic (Declaration)
Public Overridable Function FindSingle ( _
    key As TKey _
) As T

Parameters

key
Type: TKey
The key value to search for.

Return Value

The item of the collection that contains the specified key value, if found.

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


GroupJoin Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.GroupJoin Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) |
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection. Implements IIndexScanner(T).GroupJoin (Inherited from Index<(Of <(T>)>).)
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection. Implements IIndexScanner(T,TKey).GroupJoin
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence. Implements IIndexScanner(T).GroupJoin (Inherited from Index<(Of <(T>)>).)
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence. Implements IIndexScanner(T,TKey).GroupJoin
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection. Implements IIndexScanner(T,TKey).GroupJoin

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IIndexScanner(T2, TKey), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also

Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.

Implements IIndexScanner(T,TKey).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IIndexScanner<T2, TKey> source,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IIndexScanner(Of T2, TKey), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2, TKey >)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second collection joined to it.

Remarks

Matching of two elements is performed by matching their keys.

See Also

Index<(Of <(T, TKey>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(IEnumerable(T), T2, TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.

Implements IIndexScanner(T,TKey).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<IEnumerable<T>, T2, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of IEnumerable(Of T), T2, TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( IEnumerable <(Of <( T >)>), T2, TResult>)>)>)>)
A function to create a result element from an element of the second sequence and the collection of matching elements from this collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of the second collection and the corresponding enumeration of the items of this collection joined to it.

See Also

Index<(Of <(T, TKey>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
Index<(Of <(T, TKey>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

Implements IIndexScanner(T,TKey).GroupJoin

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second sequence.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second sequence joined to it.

See Also

Index<(Of <(T, TKey>)>) Class
GroupJoin Overload
C1.LiveLinq.Indexing Namespace


Join Method

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Join Method
Index<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys. Implements IIndexScanner(T).Join (Inherited from Index<(Of <(T>)>).)
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys. Implements IIndexScanner(T,TKey).Join
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys. Implements IIndexScanner(T).Join (Inherited from Index<(Of <(T>)>).)
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys. Implements IIndexScanner(T,TKey).Join

See Also

Index<(Of <(T, TKey>)>) Class
Index<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


Join(T2, TResult) Method (IIndexScanner(T2, TKey), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Join<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
Index<(Of <(T, TKey>)>) Class See Also

Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.

Implements IIndexScanner(T,TKey).Join

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> Join<T2, TResult>(
    IIndexScanner<T2, TKey> source,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function Join(Of T2, TResult) ( _
    source As IIndexScanner(Of T2, TKey), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2, TKey >)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

Remarks

Matching of two elements is performed by matching their keys.

See Also

Index<(Of <(T, TKey>)>) Class
Join Overload
C1.LiveLinq.Indexing Namespace


Join(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Join<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
Index<(Of <(T, TKey>)>) Class See Also

Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

Implements IIndexScanner(T,TKey).Join

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerable<TResult> Join<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Public Function Join(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from a second sequence's item the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

See Also

Index<(Of <(T, TKey>)>) Class
Join Overload
C1.LiveLinq.Indexing Namespace


Keys Method

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.Keys Method
Index<(Of <(T, TKey>)>) Class See Also
Gets distinct key values in all items of the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerable<TKey> Keys(
    Order order
)
Visual Basic (Declaration)
Public MustOverride Function Keys ( _
    order As Order _
) As IEnumerable(Of TKey)

Parameters

order
Type: C1.LiveLinq..::.Order
Specifies the order of the key values to sort the result.

Return Value

All distinct key values contained in the items of the collection in the specified order.

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


Index(T, TKey) Properties

[image] [image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>) Properties
Index<(Of <(T, TKey>)>) Class See Also

The Index<(Of <(T, TKey>)>) type exposes the following members.

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
ItemCount | Gets the number of elements in the indexed collection. (Inherited from Index<(Of <(T>)>).)
KeyCount | Gets the number of distinct key values in all items of this collection. (Inherited from Index<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


KeySelector Property

[image]

.NET Framework Class Library
Index<(Of <(T, TKey>)>)..::.KeySelector Property
Index<(Of <(T, TKey>)>) Class See Also
Gets the expression used to obtain key value from an element of the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Expression<Func<T, TKey>> KeySelector { get; }
Visual Basic (Declaration)
Public ReadOnly Property KeySelector As Expression(Of Func(Of T, TKey))

Return Value

An expression calculating the key value from an item (element of the collection). Typically, this is a field or a property in the item class, although more complex expressions can also be used.

See Also

Index<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


IndexCollection(T) Class

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>) Class
Members See Also
Represents a collection of indexes attached to an indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class IndexCollection<T> : ScannerCollection<T>,
    IDictionary<LambdaExpression, Index<T>>, ICollection<KeyValuePair<LambdaExpression, Index<T>>>,
    IEnumerable<KeyValuePair<LambdaExpression, Index<T>>>, ICollection<IIndexScanner<T>>,
    IEnumerable<IIndexScanner<T>>, IEnumerable
Visual Basic (Declaration)
Public Class IndexCollection(Of T) _
    Inherits ScannerCollection(Of T) _
    Implements IDictionary(Of LambdaExpression, Index(Of T)),  _
    ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))),  _
    IEnumerable(Of KeyValuePair(Of LambdaExpression, Index(Of T))),  _
    ICollection(Of IIndexScanner(Of T)), IEnumerable(Of IIndexScanner(Of T)),  _
    IEnumerable

Type Parameters

T
The type of the elements of the indexed collection.

Remarks

Any indexed collection (implementing the IIndexedSource<(Of <(T>)>) interface) has a collection of indexes attached to it.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.ScannerCollection <(Of <( T >)>)
C1.LiveLinq.Indexing..::.IndexCollection<(Of <(T>)>)

See Also

IndexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace
IIndexedSource<(Of <(T>)>)..::.Indexes
IndexedCollection<(Of <(T>)>)..::.Indexes
IndexedDataTable<(Of <(TRow>)>)..::.Indexes
View<(Of <(T>)>)..::.Indexes
ViewRowCollection..::.Indexes


IndexCollection(T) Members

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>) Members
IndexCollection<(Of <(T>)>) Class Constructors Methods Properties See Also

The IndexCollection<(Of <(T>)>) type exposes the following members.

Constructors

Name | Description
IndexCollection<(Of <(T>)>) | Initializes a new instance of the IndexCollection<(Of <(T>)>) class.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed. (Overrides ScannerCollection<(Of <(T>)>)..::.Clear()()().)
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the IndexCollection<(Of <(T>)>). (Overrides ScannerCollection<(Of <(T>)>)..::.GetEnumerator()()().)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the number of indexes in the collection. (Overrides ScannerCollection<(Of <(T>)>)..::.Count.)
Item | Gets the index with the specified key selector.

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexCollection(T) Constructor

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>) Constructor
IndexCollection<(Of <(T>)>) Class See Also
Initializes a new instance of the IndexCollection<(Of <(T>)>) class.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexCollection(
    IObservableSource<T> source
)
Visual Basic (Declaration)
Public Sub New ( _
    source As IObservableSource(Of T) _
)

Parameters

source
Type: C1.LiveLinq..::.IObservableSource <(Of <( T >)>)
The collection to be indexed.

Remarks

Normally, you don't need to create instances of the IndexCollection<(Of <(T>)>) class in your code, they already exist in the instances of LiveLinq indexed collection classes. You need to create them explicitly in code only if you define your own indexable collection class and then only if it does not inherit from IndexedCollection<(Of <(T>)>).

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexCollection(T) Methods

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>) Methods
IndexCollection<(Of <(T>)>) Class See Also

The IndexCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed. (Overrides ScannerCollection<(Of <(T>)>)..::.Clear()()().)
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the IndexCollection<(Of <(T>)>). (Overrides ScannerCollection<(Of <(T>)>)..::.GetEnumerator()()().)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Add Method

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Add Method
IndexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, CultureInfo) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)
Add(LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new index and adds it to the collection of indexes. (Inherited from ScannerCollection<(Of <(T>)>).)

See Also

IndexCollection<(Of <(T>)>) Class
IndexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
IndexCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Index(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

See Also

IndexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean)

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean)
IndexCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnque
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnque As Boolean _
) As Index(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnque
Type: System..::.Boolean
true if a unique index must be created.

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

IndexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Clear Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Clear Method
IndexCollection<(Of <(T>)>) Class See Also
Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override void Clear()
Visual Basic (Declaration)
Public Overrides Sub Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Contains Method

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Contains Method
IndexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Contains<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Determines whether an index with the specified key selector exists in the collection. (Inherited from ScannerCollection<(Of <(T>)>).)
Contains(LambdaExpression) | Determines whether an index with the specified key selector exists in the collection. (Inherited from ScannerCollection<(Of <(T>)>).)

See Also

IndexCollection<(Of <(T>)>) Class
IndexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Find Method

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Find Method
IndexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Find<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Finds an index in the collection by its key selector.
Find(LambdaExpression) | Finds an index in the collection by its key selector.
Find<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Finds an index in the collection by its key selector. (Inherited from ScannerCollection<(Of <(T>)>).)

See Also

IndexCollection<(Of <(T>)>) Class
IndexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Find(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Find<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
IndexCollection<(Of <(T>)>) Class See Also
Finds an index in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T, TKey> Find<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Find(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Index(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of an index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

An index with the given key selector, if it is found; otherwise, null.

See Also

IndexCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


Find Method (LambdaExpression)

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Find Method (LambdaExpression)
IndexCollection<(Of <(T>)>) Class See Also
Finds an index in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T> Find(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Find ( _
    keySelector As LambdaExpression _
) As Index(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

Return Value

An index with the given key selector, if it is found; otherwise, null.

See Also

IndexCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.GetEnumerator Method
IndexCollection<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the IndexCollection<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override IEnumerator<IIndexScanner<T>> GetEnumerator()
Visual Basic (Declaration)
Public Overrides Function GetEnumerator As IEnumerator(Of IIndexScanner(Of T))

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Remove Method

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Remove Method
IndexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Remove(Index<(Of <(T>)>)) | Removes an index from the collection.
Remove(LambdaExpression) | Removes an index from the collection. (Overrides ScannerCollection<(Of <(T>)>)..::.Remove(LambdaExpression).)
Remove<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Removes an index from the collection. (Inherited from ScannerCollection<(Of <(T>)>).)

See Also

IndexCollection<(Of <(T>)>) Class
IndexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Remove Method (Index(T))

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Remove Method (Index<(Of <(T>)>))
IndexCollection<(Of <(T>)>) Class See Also
Removes an index from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Remove(
    Index<T> index
)
Visual Basic (Declaration)
Public Function Remove ( _
    index As Index(Of T) _
) As Boolean

Parameters

index
Type: C1.LiveLinq.Indexing..::.Index <(Of <( T >)>)
The index to remove.

Return Value

true if an index has been removed; false if the index does not belong to this collection.

See Also

IndexCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


Remove Method (LambdaExpression)

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Remove Method (LambdaExpression)
IndexCollection<(Of <(T>)>) Class See Also
Removes an index from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override bool Remove(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Overrides Function Remove ( _
    keySelector As LambdaExpression _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

Return Value

true if an index has been removed; false if there is no index with the given key selector in the collection.

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.Remove(TKey)

See Also

IndexCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


IndexCollection(T) Properties

[image] [image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>) Properties
IndexCollection<(Of <(T>)>) Class See Also

The IndexCollection<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the number of indexes in the collection. (Overrides ScannerCollection<(Of <(T>)>)..::.Count.)
Item | Gets the index with the specified key selector.

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Count Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Count Property
IndexCollection<(Of <(T>)>) Class See Also
Gets the number of indexes in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override int Count { get; }
Visual Basic (Declaration)
Public Overrides ReadOnly Property Count As Integer

Field Value

The number of indexes in the collection.

Implements

ICollection<(Of <(T>)>)..::.Count
ICollection<(Of <(T>)>)..::.Count
ICollection<(Of <(T>)>)..::.Count

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Item Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.Item Property
IndexCollection<(Of <(T>)>) Class See Also
Gets the index with the specified key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T> this[
    LambdaExpression key
] { get; }
Visual Basic (Declaration)
Public ReadOnly Default Property Item ( _
    key As LambdaExpression _
) As Index(Of T)

Parameters

key
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexDefinition(T) Class

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>) Class
Members See Also
Contains common part of the Index and Subindex classes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexDefinition<T>
Visual Basic (Declaration)
Public MustInherit Class IndexDefinition(Of T)

Type Parameters

T
The type of the elements of indexed collection.

Remarks

This class serves as the base class of two classes: Index and Subindex. It contains properties common to these two classes.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexDefinition<(Of <(T>)>)
C1.LiveLinq.Indexing..::.Index<(Of <(T>)>)
C1.LiveLinq.Indexing..::.Subindex<(Of <(T>)>)

See Also

IndexDefinition<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace
C1.LiveLinq.Indexing..::.Index<(Of <(T, TKey>)>)


IndexDefinition(T) Members

[image] [image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>) Members
IndexDefinition<(Of <(T>)>) Class Methods Properties See Also

The IndexDefinition<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index.
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection.
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key.
Locale | Gets the locale information used to compare strings in the index.
Root | Gets the root index in an index/subindex hierarchy.
Subindexes | Gets the collection of subindexes added to this index.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexDefinition(T) Methods

[image] [image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>) Methods
IndexDefinition<(Of <(T>)>) Class See Also

The IndexDefinition<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexDefinition(T) Properties

[image] [image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>) Properties
IndexDefinition<(Of <(T>)>) Class See Also

The IndexDefinition<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index.
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection.
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key.
Locale | Gets the locale information used to compare strings in the index.
Root | Gets the root index in an index/subindex hierarchy.
Subindexes | Gets the collection of subindexes added to this index.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Algorithm Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.Algorithm Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the indexing algorithm used by the index.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IndexingAlgorithm Algorithm { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property Algorithm As IndexingAlgorithm

Field Value

An IndexingAlgorithm used by the index. In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexes.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


KeyIsUnique Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.KeyIsUnique Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets a value that indicates whether the key used in this index is a unique key for the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool KeyIsUnique { get; private set; }
Visual Basic (Declaration)
Public Property KeyIsUnique As Boolean

Field Value

true if the key is unique; otherwise, false

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique in the IndexCollection.Add method.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the collection. An attempt to modify the collection violating the uniqueness throws an InvalidOperationException.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


KeySelector Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.KeySelector Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the expression used to obtain key value from an element of the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public LambdaExpression KeySelector { get; private set; }
Visual Basic (Declaration)
Public Property KeySelector As LambdaExpression

Field Value

An expression calculating the key value from an item (element of the collection). Typically, this is a field or a property in the item class, although more complex expressions can also be used.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


KeyType Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.KeyType Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the type of the index key.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Type KeyType { get; }
Visual Basic (Declaration)
Public ReadOnly Property KeyType As Type

Field Value

The type of the result of the KeySelector expression.

Remarks

This type is the same as the TKey type for Index<(Of <(T, TKey>)>) and Subindex<(Of <(T, TKey>)>) objects.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Locale Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.Locale Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the locale information used to compare strings in the index.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public CultureInfo Locale { get; private set; }
Visual Basic (Declaration)
Public Property Locale As CultureInfo

Field Value

A CultureInfo that contains data about the user's locale. The default is CurrentCulture.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Root Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.Root Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the root index in an index/subindex hierarchy.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexDefinition<T> Root { get; }
Visual Basic (Declaration)
Public ReadOnly Property Root As IndexDefinition(Of T)

Field Value

For a subindex, this is an Index<(Of <(T>)>) to which the subindex belongs (maybe indirectly, through several levels of parent subindexes). For an index, this is always the same object as the index itself.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Subindexes Property

[image]

.NET Framework Class Library
IndexDefinition<(Of <(T>)>)..::.Subindexes Property
IndexDefinition<(Of <(T>)>) Class See Also
Gets the collection of subindexes added to this index.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public SubindexCollection<T> Subindexes { get; }
Visual Basic (Declaration)
Public ReadOnly Property Subindexes As SubindexCollection(Of T)

Field Value

The SubindexCollection<(Of <(T>)>) that contains the subindexes of this index.

See Also

IndexDefinition<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IndexingAlgorithm Class

[image]

.NET Framework Class Library
IndexingAlgorithm Class
Members See Also
Defines the kind of an index, the algorithm used by that index. Currently, the RedBlackTree algorithm is always used.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexingAlgorithm
Visual Basic (Declaration)
Public MustInherit Class IndexingAlgorithm

Remarks

In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexing.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexingAlgorithm

See Also

IndexingAlgorithm Members
C1.LiveLinq.Indexing Namespace


IndexingAlgorithm Members

[image] [image]

.NET Framework Class Library
IndexingAlgorithm Members
IndexingAlgorithm Class Methods Fields See Also

The IndexingAlgorithm type exposes the following members.

Methods

Name | Description
CreateIndex<(Of <(T, TKey>)>) | Creates a new index.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Fields

Name | Description
RedBlackTree | The red-black tree algorithm, a type of self-balancing binary search tree widely used in computer science because it has good performance that does not significantly degrade even in worst cases.

See Also

IndexingAlgorithm Class
C1.LiveLinq.Indexing Namespace


IndexingAlgorithm Fields

[image] [image]

.NET Framework Class Library
IndexingAlgorithm Fields
IndexingAlgorithm Class See Also

The IndexingAlgorithm type exposes the following members.

Fields

Name | Description
RedBlackTree | The red-black tree algorithm, a type of self-balancing binary search tree widely used in computer science because it has good performance that does not significantly degrade even in worst cases.

See Also

IndexingAlgorithm Class
C1.LiveLinq.Indexing Namespace


RedBlackTree Field

[image]

.NET Framework Class Library
IndexingAlgorithm..::.RedBlackTree Field
IndexingAlgorithm Class See Also
The red-black tree algorithm, a type of self-balancing binary search tree widely used in computer science because it has good performance that does not significantly degrade even in worst cases.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static readonly IndexingAlgorithm RedBlackTree
Visual Basic (Declaration)
Public Shared ReadOnly RedBlackTree As IndexingAlgorithm

See Also

IndexingAlgorithm Class
C1.LiveLinq.Indexing Namespace


IndexingAlgorithm Methods

[image] [image]

.NET Framework Class Library
IndexingAlgorithm Methods
IndexingAlgorithm Class See Also

The IndexingAlgorithm type exposes the following members.

Methods

Name | Description
CreateIndex<(Of <(T, TKey>)>) | Creates a new index.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexingAlgorithm Class
C1.LiveLinq.Indexing Namespace


CreateIndex(T, TKey) Method

[image]

.NET Framework Class Library
IndexingAlgorithm..::.CreateIndex<(Of <(T, TKey>)>) Method
IndexingAlgorithm Class See Also
Creates a new index.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Index<T, TKey> CreateIndex<T, TKey>(
    IObservableSource<T> source,
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function CreateIndex(Of T, TKey) ( _
    source As IObservableSource(Of T), _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    locale As CultureInfo _
) As Index(Of T, TKey)

Parameters

source
Type: C1.LiveLinq..::.IObservableSource <(Of <(T>)>)
The collection to be indexed.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the index (default: CultureInfo.CurrentCulture).

Type Parameters

T
The type of the elements of the collection to index.
TKey
The type of the index key.

Return Value

The new index.

Remarks

Normally, you don't need to use this method. Indexes are usually created in code by calling IndexCollection.Add, or their creation can be enforced in LINQ queries by using the Indexed hint. This method should be used only in special situations where all you want is to index a collection without an overhead of maintaining a collection of indexes, or you need an index that exists separately from the collection of indexes maintained by the source. Unlike the standard ways of creating indexes, this method only creates an index object and attaches it to the source (so it will be automatically synchronized with the source when the source is modified), but the created index is not added to IndexCollection<(Of <(T>)>).

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique. But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

IndexingAlgorithm Class
C1.LiveLinq.Indexing Namespace


IndexingException Class

[image]

.NET Framework Class Library
IndexingException Class
Members See Also
Represents an exception that is thrown when errors are generated using LiveLinq components.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
[SerializableAttribute]
public class IndexingException : Exception
Visual Basic (Declaration)
<SerializableAttribute> _
Public Class IndexingException _
    Inherits Exception

Inheritance Hierarchy

System..::.Object
System..::.Exception
C1.LiveLinq.Indexing..::.IndexingException

See Also

IndexingException Members
C1.LiveLinq.Indexing Namespace


IndexingException Members

[image] [image]

.NET Framework Class Library
IndexingException Members
IndexingException Class Constructors Methods Properties See Also

The IndexingException type exposes the following members.

Constructors

Name | Description
IndexingException | Overloaded.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

IndexingException Class
C1.LiveLinq.Indexing Namespace


IndexingException Constructor

[image] [image]

.NET Framework Class Library
IndexingException Constructor
IndexingException Class See Also

Overload List

Name | Description
IndexingException()()() | Initializes a new instance of the IndexingException class. This is the default constructor.
IndexingException(String) | Initializes a new instance of the IndexingException class with the specified string.
IndexingException(SerializationInfo, StreamingContext) | Initializes a new instance of the IndexingException class with the specified serialization information and context.
IndexingException(String, Exception) | Initializes a new instance of the IndexingException class with the specified string and inner exception.

See Also

IndexingException Class
IndexingException Members
C1.LiveLinq.Indexing Namespace


IndexingException Constructor

[image]

.NET Framework Class Library
IndexingException Constructor
IndexingException Class See Also
Initializes a new instance of the IndexingException class. This is the default constructor.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexingException()
Visual Basic (Declaration)
Public Sub New

See Also

IndexingException Class
IndexingException Overload
C1.LiveLinq.Indexing Namespace


IndexingException Constructor (String)

[image]

.NET Framework Class Library
IndexingException Constructor (String)
IndexingException Class See Also
Initializes a new instance of the IndexingException class with the specified string.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexingException(
    string message
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.

See Also

IndexingException Class
IndexingException Overload
C1.LiveLinq.Indexing Namespace


IndexingException Constructor (SerializationInfo, StreamingContext)

[image]

.NET Framework Class Library
IndexingException Constructor (SerializationInfo, StreamingContext)
IndexingException Class See Also
Initializes a new instance of the IndexingException class with the specified serialization information and context.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
protected IndexingException(
    SerializationInfo info,
    StreamingContext context
)
Visual Basic (Declaration)
Protected Sub New ( _
    info As SerializationInfo, _
    context As StreamingContext _
)

Parameters

info
Type: System.Runtime.Serialization..::.SerializationInfo
The data necessary to serialize or deserialize an object.
context
Type: System.Runtime.Serialization..::.StreamingContext
Description of the source and destination of the specified serialized stream.

See Also

IndexingException Class
IndexingException Overload
C1.LiveLinq.Indexing Namespace


IndexingException Constructor (String, Exception)

[image]

.NET Framework Class Library
IndexingException Constructor (String, Exception)
IndexingException Class See Also
Initializes a new instance of the IndexingException class with the specified string and inner exception.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexingException(
    string message,
    Exception inner
)
Visual Basic (Declaration)
Public Sub New ( _
    message As String, _
    inner As Exception _
)

Parameters

message
Type: System..::.String
The string to display when the exception is thrown.
inner
Type: System..::.Exception
A reference to an inner exception.

See Also

IndexingException Class
IndexingException Overload
C1.LiveLinq.Indexing Namespace


IndexingException Methods

[image] [image]

.NET Framework Class Library
IndexingException Methods
IndexingException Class See Also

The IndexingException type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetBaseException | When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. (Inherited from Exception.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetObjectData | When overridden in a derived class, sets the SerializationInfo with information about the exception. (Inherited from Exception.)
GetType | Gets the runtime type of the current instance. (Inherited from Exception.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Creates and returns a string representation of the current exception. (Inherited from Exception.)

See Also

IndexingException Class
C1.LiveLinq.Indexing Namespace


IndexingException Properties

[image] [image]

.NET Framework Class Library
IndexingException Properties
IndexingException Class See Also

The IndexingException type exposes the following members.

Properties

Name | Description
Data | Gets a collection of key/value pairs that provide additional user-defined information about the exception. (Inherited from Exception.)
HelpLink | Gets or sets a link to the help file associated with this exception. (Inherited from Exception.)
HResult | Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. (Inherited from Exception.)
InnerException | Gets the Exception instance that caused the current exception. (Inherited from Exception.)
Message | Gets a message that describes the current exception. (Inherited from Exception.)
Source | Gets or sets the name of the application or the object that causes the error. (Inherited from Exception.)
StackTrace | Gets a string representation of the frames on the call stack at the time the current exception was thrown. (Inherited from Exception.)
TargetSite | Gets the method that throws the current exception. (Inherited from Exception.)

See Also

IndexingException Class
C1.LiveLinq.Indexing Namespace


ScannerCollection(T) Class

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>) Class
Members See Also
Represents a collection of indexes or subindexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class ScannerCollection<T> : ICollection<IIndexScanner<T>>,
    IEnumerable<IIndexScanner<T>>, IEnumerable
Visual Basic (Declaration)
Public MustInherit Class ScannerCollection(Of T) _
    Implements ICollection(Of IIndexScanner(Of T)), IEnumerable(Of IIndexScanner(Of T)),  _
    IEnumerable

Type Parameters

T
The type of the elements of the indexed collection.

Remarks

Any indexed collection (implementing the IIndexedSource<(Of <(T>)>) interface) has a collection of indexes attached to it. ScannerCollection<T> is the base class for the collection of indexes, IndexCollection<(Of <(T>)>)

The ScannerCollection<(Of <(T>)>) class is also used in the Indexes property of the IndexQuery<(Of <(T>)>) class, the result of an indexing search operation such as Index.Find and others, where it contains subindexes.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.ScannerCollection<(Of <(T>)>)
C1.LiveLinq.Indexing..::.IndexCollection<(Of <(T>)>)

See Also

ScannerCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


ScannerCollection(T) Members

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>) Members
ScannerCollection<(Of <(T>)>) Class Methods Properties See Also

The ScannerCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed.
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the ScannerCollection<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the number of indexes in the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ScannerCollection(T) Methods

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>) Methods
ScannerCollection<(Of <(T>)>) Class See Also

The ScannerCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed.
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the ScannerCollection<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Add Method

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add Method
ScannerCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, CultureInfo) | Creates a new index and adds it to the collection of indexes.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new index and adds it to the collection of indexes.
Add(LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new index and adds it to the collection of indexes.

See Also

ScannerCollection<(Of <(T>)>) Class
ScannerCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean)
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection (default: false).

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean)
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the index does not exist prior to this method call (default: false). If an index with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean, CultureInfo)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, CultureInfo)
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    locale As CultureInfo _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the index does not exist prior to this method call (default: false). If an index with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the index (default: CultureInfo.CurrentCulture).

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean, IndexingAlgorithm, CultureInfo)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, IndexingAlgorithm, CultureInfo)
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    IndexingAlgorithm algorithm,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    algorithm As IndexingAlgorithm, _
    locale As CultureInfo _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the index does not exist prior to this method call (default: false). If an index with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
algorithm
Type: C1.LiveLinq.Indexing..::.IndexingAlgorithm
An IndexingAlgorithm used by the index. In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexes.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the index (default: CultureInfo.CurrentCulture).

Type Parameters

TKey
The type of the index key.

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add Method (LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Add Method (LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo)
ScannerCollection<(Of <(T>)>) Class See Also
Creates a new index and adds it to the collection of indexes.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T> Add(
    LambdaExpression keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    IndexingAlgorithm algorithm,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add ( _
    keySelector As LambdaExpression, _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    algorithm As IndexingAlgorithm, _
    locale As CultureInfo _
) As IIndexScanner(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of the index, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this index is a unique key for the indexed collection (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the index does not exist prior to this method call. If an index with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
algorithm
Type: C1.LiveLinq.Indexing..::.IndexingAlgorithm
An IndexingAlgorithm used by the index. In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexes.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the index (default: CultureInfo.CurrentCulture).

Return Value

The new index added to the collection of indexes.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

See Also

ScannerCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Clear Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Clear Method
ScannerCollection<(Of <(T>)>) Class See Also
Clears the collection of all indexes. All indexes are detached from the indexed collection and destroyed.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract void Clear()
Visual Basic (Declaration)
Public MustOverride Sub Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Contains Method

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Contains Method
ScannerCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Contains<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Determines whether an index with the specified key selector exists in the collection.
Contains(LambdaExpression) | Determines whether an index with the specified key selector exists in the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
ScannerCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Contains(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Contains<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
ScannerCollection<(Of <(T>)>) Class See Also
Determines whether an index with the specified key selector exists in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Contains(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of an index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

true if an index with the specified key selector is found in the collection; otherwise, false.

See Also

ScannerCollection<(Of <(T>)>) Class
Contains Overload
C1.LiveLinq.Indexing Namespace


Contains Method (LambdaExpression)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Contains Method (LambdaExpression)
ScannerCollection<(Of <(T>)>) Class See Also
Determines whether an index with the specified key selector exists in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Contains ( _
    keySelector As LambdaExpression _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

Return Value

true if an index with the specified key selector is found in the collection; otherwise, false.

See Also

ScannerCollection<(Of <(T>)>) Class
Contains Overload
C1.LiveLinq.Indexing Namespace


Find Method

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Find Method
ScannerCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Find<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Finds an index in the collection by its key selector.
Find(LambdaExpression) | Finds an index in the collection by its key selector.

See Also

ScannerCollection<(Of <(T>)>) Class
ScannerCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Find(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Find<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
ScannerCollection<(Of <(T>)>) Class See Also
Finds an index in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T, TKey> Find<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Find(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As IIndexScanner(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of an index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

An index with the given key selector, if it is found; otherwise, null.

See Also

ScannerCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


Find Method (LambdaExpression)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Find Method (LambdaExpression)
ScannerCollection<(Of <(T>)>) Class See Also
Finds an index in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T> Find(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Find ( _
    keySelector As LambdaExpression _
) As IIndexScanner(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

Return Value

An index with the given key selector, if it is found; otherwise, null.

See Also

ScannerCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.GetEnumerator Method
ScannerCollection<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the ScannerCollection<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerator<IIndexScanner<T>> GetEnumerator()
Visual Basic (Declaration)
Public MustOverride Function GetEnumerator As IEnumerator(Of IIndexScanner(Of T))

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Remove Method

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Remove Method
ScannerCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Remove<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Removes an index from the collection.
Remove(LambdaExpression) | Removes an index from the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
ScannerCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Remove(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Remove<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
ScannerCollection<(Of <(T>)>) Class See Also
Removes an index from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Remove<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Remove(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of an index, see KeySelector.

Type Parameters

TKey
The type of the index key.

Return Value

true if an index has been removed; false if there is no index with the given key selector in the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


Remove Method (LambdaExpression)

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Remove Method (LambdaExpression)
ScannerCollection<(Of <(T>)>) Class See Also
Removes an index from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract bool Remove(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public MustOverride Function Remove ( _
    keySelector As LambdaExpression _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an index, see KeySelector.

Return Value

true if an index has been removed; false if there is no index with the given key selector in the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


ScannerCollection(T) Properties

[image] [image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>) Properties
ScannerCollection<(Of <(T>)>) Class See Also

The ScannerCollection<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the number of indexes in the collection.

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Count Property

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.Count Property
ScannerCollection<(Of <(T>)>) Class See Also
Gets the number of indexes in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract int Count { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property Count As Integer

Field Value

The number of indexes in the collection.

Implements

ICollection<(Of <(T>)>)..::.Count

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T) Class

[image]

.NET Framework Class Library
Subindex<(Of <(T>)>) Class
Members See Also
Base class for the Subindex<(Of <(T, TKey>)>) class.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class Subindex<T> : IndexDefinition<T>
Visual Basic (Declaration)
Public MustInherit Class Subindex(Of T) _
    Inherits IndexDefinition(Of T)

Type Parameters

T
The type of the elements of the collection to index.

Remarks

You don't typically use the Subindex<(Of <(T>)>) class directly. It provides functionality of the Subindex<(Of <(T, TKey>)>) class that does not depend on the index key type. The base class Subindex<(Of <(T>)>) is needed only if the index key type is not known, usually in general-purpose code intended for reuse with different key types.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexDefinition <(Of <( T >)>)
C1.LiveLinq.Indexing..::.Subindex<(Of <(T>)>)
C1.LiveLinq.Indexing..::.Subindex<(Of <(T, TKey>)>)

See Also

Subindex<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Subindex(T) Members

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T>)>) Members
Subindex<(Of <(T>)>) Class Methods Properties See Also

The Subindex<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Parent | Parent of this subindex definition in the index/subindexes hierarchy.
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Subindex<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T) Methods

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T>)>) Methods
Subindex<(Of <(T>)>) Class See Also

The Subindex<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Subindex<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T) Properties

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T>)>) Properties
Subindex<(Of <(T>)>) Class See Also

The Subindex<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Parent | Parent of this subindex definition in the index/subindexes hierarchy.
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Subindex<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Parent Property

[image]

.NET Framework Class Library
Subindex<(Of <(T>)>)..::.Parent Property
Subindex<(Of <(T>)>) Class See Also
Parent of this subindex definition in the index/subindexes hierarchy.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexDefinition<T> Parent { get; protected internal set; }
Visual Basic (Declaration)
Public Property Parent As IndexDefinition(Of T)

See Also

Subindex<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T, TKey) Class

[image]

.NET Framework Class Library
Subindex<(Of <(T, TKey>)>) Class
Members See Also
Defines a subindex, an index definition subordinate to another index definition, its parent.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class Subindex<T, TKey> : Subindex<T>
Visual Basic (Declaration)
Public MustInherit Class Subindex(Of T, TKey) _
    Inherits Subindex(Of T)

Type Parameters

T
The type of the elements of the collection to index.
TKey
The type of the index key.

Remarks

An index (Index<(Of <(T, TKey>)>)) can have subindexes. Subindexes are optional, not required for any indexing tasks, but can provide additional optimization and help minimize memory requirements when a collection is indexed by multi-level (multi-field) keys.

Suppose we want to index a Customers table by two fields, (City, Rating), perhaps for speeding up queries like

Copy CodeC#
from c in Customers where c.City == "London" && c.Rating == 1 select c
We can do it by defining an index with key selector c => new { c.City, c.Rating } , that will index the table by two fields, creating a multi-field index. Such index will suffice for optimizing the query above, but it will not optimize, for example, the following query:
Copy CodeC#
from c in Customers where c.City == "London" && c.Rating > 2 select c
 Also, multi-field indexes occupy more memory than necessary because they have to store repeated field values.

Subindexes provide a better alternative for optimizing multi-field searches. In the example above, we can define an index by City and create a subindex of that index, by Rating. Using subindexes becomes even more effective when, as it is often happens, we also need queries to search by additional fields, like, for example, if we need to search by ContactTitle inside a city in addition to the search by Rating inside a city:

Copy CodeC#
from c in Customers where c.City == "London" && c.ContactTitle == "Owner" select c
All we have to do now is to add a second subindex to the index by City, a subindex by ContactTitle.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.IndexDefinition <(Of <( T >)>)
C1.LiveLinq.Indexing..::.Subindex <(Of <(T>)>)
C1.LiveLinq.Indexing..::.Subindex<(Of <(T, TKey>)>)

See Also

Subindex<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing Namespace


Subindex(T, TKey) Members

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T, TKey>)>) Members
Subindex<(Of <(T, TKey>)>) Class Methods Properties See Also

The Subindex<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Parent | Parent of this subindex definition in the index/subindexes hierarchy. (Inherited from Subindex<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Subindex<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T, TKey) Methods

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T, TKey>)>) Methods
Subindex<(Of <(T, TKey>)>) Class See Also

The Subindex<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

Subindex<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


Subindex(T, TKey) Properties

[image] [image]

.NET Framework Class Library
Subindex<(Of <(T, TKey>)>) Properties
Subindex<(Of <(T, TKey>)>) Class See Also

The Subindex<(Of <(T, TKey>)>) type exposes the following members.

Properties

Name | Description
Algorithm | Gets the indexing algorithm used by the index. (Inherited from IndexDefinition<(Of <(T>)>).)
KeyIsUnique | Gets a value that indicates whether the key used in this index is a unique key for the collection. (Inherited from IndexDefinition<(Of <(T>)>).)
KeySelector | Gets the expression used to obtain key value from an element of the indexed collection.
KeyType | Gets the type of the index key. (Inherited from IndexDefinition<(Of <(T>)>).)
Locale | Gets the locale information used to compare strings in the index. (Inherited from IndexDefinition<(Of <(T>)>).)
Parent | Parent of this subindex definition in the index/subindexes hierarchy. (Inherited from Subindex<(Of <(T>)>).)
Root | Gets the root index in an index/subindex hierarchy. (Inherited from IndexDefinition<(Of <(T>)>).)
Subindexes | Gets the collection of subindexes added to this index. (Inherited from IndexDefinition<(Of <(T>)>).)

See Also

Subindex<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


KeySelector Property

[image]

.NET Framework Class Library
Subindex<(Of <(T, TKey>)>)..::.KeySelector Property
Subindex<(Of <(T, TKey>)>) Class See Also
Gets the expression used to obtain key value from an element of the indexed collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Expression<Func<T, TKey>> KeySelector { get; }
Visual Basic (Declaration)
Public ReadOnly Property KeySelector As Expression(Of Func(Of T, TKey))

Field Value

An expression calculating the key value from an item (element of the collection). Typically, this is a field or a property in the item class, although more complex expressions can also be used.

See Also

Subindex<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing Namespace


SubindexCollection(T) Class

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>) Class
Members See Also
Represents a collection of subindexes attached to an IndexDefinition<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public sealed class SubindexCollection<T> : IList<Subindex<T>>,
    ICollection<Subindex<T>>, IEnumerable<Subindex<T>>, IEnumerable
Visual Basic (Declaration)
Public NotInheritable Class SubindexCollection(Of T) _
    Implements IList(Of Subindex(Of T)), ICollection(Of Subindex(Of T)),  _
    IEnumerable(Of Subindex(Of T)), IEnumerable

Type Parameters

T
The type of the elements of the collection to index.

Remarks

A Subindex<(Of <(T, TKey>)>) is attached to its parent index definition, which is an Index<(Of <(T, TKey>)>) or another Subindex<(Of <(T, TKey>)>). The subindexes collection is stored in the parent's Subindexes property.

Subindexes are optional, not required for any indexing tasks, but can provide additional optimization and help minimize memory requirements when a collection is indexed by multi-level (multi-field) keys.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing..::.SubindexCollection<(Of <(T>)>)

See Also

SubindexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


SubindexCollection(T) Members

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>) Members
SubindexCollection<(Of <(T>)>) Class Methods Properties See Also

The SubindexCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all subindexes. All subindexes are detached from the parent and destroyed.
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the SubindexCollection<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the number of subindexes in the collection.
Item | Gets the subindex object at the specified ordinal position in the collection.

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


SubindexCollection(T) Methods

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>) Methods
SubindexCollection<(Of <(T>)>) Class See Also

The SubindexCollection<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Add | Overloaded.
Clear | Clears the collection of all subindexes. All subindexes are detached from the parent and destroyed.
Contains | Overloaded.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
Find | Overloaded.
GetEnumerator | Returns an enumerator that iterates through the SubindexCollection<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Add Method

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add Method
SubindexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Creates a new subindex and attaches it to its parent's Subindexes collection.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean) | Creates a new subindex and attaches it to its parent's Subindexes collection.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean) | Creates a new subindex and attaches it to its parent's Subindexes collection.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, CultureInfo) | Creates a new subindex and attaches it to its parent's Subindexes collection.
Add<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new subindex and attaches it to its parent's Subindexes collection.
Add(LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo) | Creates a new subindex and attaches it to its parent's Subindexes collection.

See Also

SubindexCollection<(Of <(T>)>) Class
SubindexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the subindex, see KeySelector.

Type Parameters

TKey
The type of the subindex key.

Return Value

The new subindex added to its parent's Subindexes collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean)
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the subindex, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this subindex is unique for any given value of the parent key (default: false).

Type Parameters

TKey
The type of the subindex key.

Return Value

The new subindex added to its parent's Subindexes collection.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

For a subindex, uniqueness means that any given pair of parent key and subindex key values uniquely determines an item in the indexed collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean)
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the subindex, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this subindex is unique for any given value of the parent key (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the subindex does not exist prior to this method call (default: false). If a subindex with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.

Type Parameters

TKey
The type of the subindex key.

Return Value

The new subindex added to its parent's Subindexes collection.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

For a subindex, uniqueness means that any given pair of parent key and subindex key values uniquely determines an item in the indexed collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean, CultureInfo)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, CultureInfo)
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    locale As CultureInfo _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the subindex, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this subindex is unique for any given value of the parent key (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the subindex does not exist prior to this method call (default: false). If a subindex with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the subindex (default: CultureInfo.CurrentCulture).

Type Parameters

TKey
The type of the subindex key.

Return Value

The new subindex added to its parent's Subindexes collection.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

For a subindex, uniqueness means that any given pair of parent key and subindex key values uniquely determines an item in the indexed collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add(TKey) Method (Expression(Func(T, TKey)), Boolean, Boolean, IndexingAlgorithm, CultureInfo)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Boolean, Boolean, IndexingAlgorithm, CultureInfo)
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Add<TKey>(
    Expression<Func<T, TKey>> keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    IndexingAlgorithm algorithm,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    algorithm As IndexingAlgorithm, _
    locale As CultureInfo _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of the subindex, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this subindex is unique for any given value of the parent key (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the subindex does not exist prior to this method call (default: false). If a subindex with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
algorithm
Type: C1.LiveLinq.Indexing..::.IndexingAlgorithm
An IndexingAlgorithm used by the subindex. In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexing.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the subindex (default: CultureInfo.CurrentCulture).

Type Parameters

TKey
The type of the subindex key.

Return Value

The new subindex added to its parent's Subindexes collection.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

For a subindex, uniqueness means that any given pair of parent key and subindex key values uniquely determines an item in the indexed collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Add Method (LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Add Method (LambdaExpression, Boolean, Boolean, IndexingAlgorithm, CultureInfo)
SubindexCollection<(Of <(T>)>) Class See Also
Creates a new subindex and attaches it to its parent's Subindexes collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T> Add(
    LambdaExpression keySelector,
    bool keyIsUnique,
    bool onlyOnce,
    IndexingAlgorithm algorithm,
    CultureInfo locale
)
Visual Basic (Declaration)
Public Function Add ( _
    keySelector As LambdaExpression, _
    keyIsUnique As Boolean, _
    onlyOnce As Boolean, _
    algorithm As IndexingAlgorithm, _
    locale As CultureInfo _
) As Subindex(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of the subindex, see KeySelector.
keyIsUnique
Type: System..::.Boolean
Specifies whether the key used in this subindex is unique for any given value of the parent key (default: false).
onlyOnce
Type: System..::.Boolean
Specifies whether it is required that the subindex does not exist prior to this method call. If a subindex with this keySelector already exists, an exception is thrown if it is true, and this method call is ignored if it is false.
algorithm
Type: C1.LiveLinq.Indexing..::.IndexingAlgorithm
An IndexingAlgorithm used by the subindex. In the current version, only one algorithm is supported, RedBlackTree. Later versions may support other algorithms, such as bitmap or hash indexing.
locale
Type: System.Globalization..::.CultureInfo
Locale information used to compare strings in the subindex (default: CultureInfo.CurrentCulture).

Return Value

The new subindex added to its parent's Subindexes collection.

Remarks

A unique index occupies less memory and performs better than a non-unique index (although the difference isn't dramatic). Therefore, for unique keys, it's recommended to specify the corresponding index as unique.

But do that only if you are sure that the key is indeed unique, as it imposes a uniqueness constraint on the indexed collection. An attempt to modify the indexed collection violating the uniqueness throws an InvalidOperationException.

For a subindex, uniqueness means that any given pair of parent key and subindex key values uniquely determines an item in the indexed collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Add Overload
C1.LiveLinq.Indexing Namespace


Clear Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Clear Method
SubindexCollection<(Of <(T>)>) Class See Also
Clears the collection of all subindexes. All subindexes are detached from the parent and destroyed.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void Clear()
Visual Basic (Declaration)
Public Sub Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Contains Method

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Contains Method
SubindexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Contains<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Determines whether a subindex with the specified key selector exists in the collection.
Contains(LambdaExpression) | Determines whether a subindex with the specified key selector exists in the collection.

See Also

SubindexCollection<(Of <(T>)>) Class
SubindexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Contains(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Contains<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
SubindexCollection<(Of <(T>)>) Class See Also
Determines whether a subindex with the specified key selector exists in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Contains(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of a subindex, see KeySelector.

Type Parameters

TKey
The type of the subindex key.

Return Value

true if a subindex with the specified key selector is found in the collection; otherwise, false.

See Also

SubindexCollection<(Of <(T>)>) Class
Contains Overload
C1.LiveLinq.Indexing Namespace


Contains Method (LambdaExpression)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Contains Method (LambdaExpression)
SubindexCollection<(Of <(T>)>) Class See Also
Determines whether a subindex with the specified key selector exists in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Contains ( _
    keySelector As LambdaExpression _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of a subindex, see KeySelector.

Return Value

true if a subindex with the specified key selector is found in the collection; otherwise, false.

See Also

SubindexCollection<(Of <(T>)>) Class
Contains Overload
C1.LiveLinq.Indexing Namespace


Find Method

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Find Method
SubindexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Find<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Finds a subindex in the collection by its key selector.
Find(LambdaExpression) | Finds a subindex in the collection by its key selector.

See Also

SubindexCollection<(Of <(T>)>) Class
SubindexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Find(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Find<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
SubindexCollection<(Of <(T>)>) Class See Also
Finds a subindex in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T, TKey> Find<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function Find(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As Subindex(Of T, TKey)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
Key selector expression of an subindex, see KeySelector.

Type Parameters

TKey
The type of the subindex key.

Return Value

A subindex with the given key selector, if it is found; otherwise, null.

See Also

SubindexCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


Find Method (LambdaExpression)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Find Method (LambdaExpression)
SubindexCollection<(Of <(T>)>) Class See Also
Finds a subindex in the collection by its key selector.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T> Find(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Find ( _
    keySelector As LambdaExpression _
) As Subindex(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of an subindex, see KeySelector.

Return Value

A subindex with the given key selector, if it is found; otherwise, null.

See Also

SubindexCollection<(Of <(T>)>) Class
Find Overload
C1.LiveLinq.Indexing Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.GetEnumerator Method
SubindexCollection<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the SubindexCollection<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerator<Subindex<T>> GetEnumerator()
Visual Basic (Declaration)
Public Function GetEnumerator As IEnumerator(Of Subindex(Of T))

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Remove Method

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Remove Method
SubindexCollection<(Of <(T>)>) Class See Also

Overload List

Name | Description
Remove(Subindex<(Of <(T>)>)) | Removes a subindex from the collection.
Remove(LambdaExpression) | Removes a subindex from the collection.

See Also

SubindexCollection<(Of <(T>)>) Class
SubindexCollection<(Of <(T>)>) Members
C1.LiveLinq.Indexing Namespace


Remove Method (Subindex(T))

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Remove Method (Subindex<(Of <(T>)>))
SubindexCollection<(Of <(T>)>) Class See Also
Removes a subindex from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Remove(
    Subindex<T> definition
)
Visual Basic (Declaration)
Public Function Remove ( _
    definition As Subindex(Of T) _
) As Boolean

Parameters

definition
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)
The subindex to remove.

Return Value

true if a subindex has been removed; false if the subindex does not belong to this collection.

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

SubindexCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


Remove Method (LambdaExpression)

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Remove Method (LambdaExpression)
SubindexCollection<(Of <(T>)>) Class See Also
Removes a subindex from the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Remove(
    LambdaExpression keySelector
)
Visual Basic (Declaration)
Public Function Remove ( _
    keySelector As LambdaExpression _
) As Boolean

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
Key selector expression of a subindex, see KeySelector.

Return Value

true if a subindex has been removed; false if there is no subindex with the given key selector in the collection.

See Also

SubindexCollection<(Of <(T>)>) Class
Remove Overload
C1.LiveLinq.Indexing Namespace


SubindexCollection(T) Properties

[image] [image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>) Properties
SubindexCollection<(Of <(T>)>) Class See Also

The SubindexCollection<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the number of subindexes in the collection.
Item | Gets the subindex object at the specified ordinal position in the collection.

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Count Property

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Count Property
SubindexCollection<(Of <(T>)>) Class See Also
Gets the number of subindexes in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int Count { get; }
Visual Basic (Declaration)
Public ReadOnly Property Count As Integer

Field Value

The number of subindexes in the collection.

Implements

ICollection<(Of <(T>)>)..::.Count

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


Item Property

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.Item Property
SubindexCollection<(Of <(T>)>) Class See Also
Gets the subindex object at the specified ordinal position in the collection.

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Subindex<T> this[
    int ordinal
] { get; }
Visual Basic (Declaration)
Public ReadOnly Default Property Item ( _
    ordinal As Integer _
) As Subindex(Of T)

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal position of the subindex to find

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


C1.LiveLinq.Indexing.Search Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.Indexing.Search Namespace

Classes

Class | Description
GroupingQuery<(Of <(T>)>) | Represents a collection of IndexedGroup<(Of <(T>)>), groups of elements with the same key, resulting from a search operation with grouping. This class has a derived class GroupingQuery<(Of <(TKey, T>)>) with specific type of the key used for the index search.
GroupingQuery<(Of <(TKey, T>)>) | Represents a collection of IndexedGroup<(Of <(TKey, T>)>), groups of elements with the same key, resulting from a search operation with grouping.
IndexedGroup<(Of <(T>)>) | Represents a group of elements with the same key belonging to a collection of groups resulting from a search operation with grouping. This class has a derived class IndexedGroup<(Of <(TKey, T>)>) with specific key type.
IndexedGroup<(Of <(TKey, T>)>) | Represents a group of elements with the same key belonging to a collection of groups resulting from a search operation with grouping.
IndexQuery<(Of <(T>)>) | Represents a collection that is the result of an index search. Objects of this class are returned by the IIndexScanner<(Of <(T>)>) search methods. This class has a derived class IndexQuery<(Of <(T, TKey>)>) with specific type of the key used for the index search.
IndexQuery<(Of <(T, TKey>)>) | Represents a collection that is the result of an index search. Objects of this class are returned by the IIndexScanner<(Of <(T, TKey>)>) search methods.

Interfaces

Interface | Description
IIndexScanner<(Of <(T>)>) | Represents an index or a subindex in its capacity of scanning through data. Provides methods for searching data items.
IIndexScanner<(Of <(T, TKey>)>) | Represents an index or a subindex in its capacity of scanning through data. Provides methods for searching data items.

Enumerations

Enumeration | Description
JoinOperator | A comparison operator to match elements in a join operation.


GroupingQuery(T) Class

[image]

.NET Framework Class Library
GroupingQuery<(Of <(T>)>) Class
Members See Also
Represents a collection of IndexedGroup<(Of <(T>)>), groups of elements with the same key, resulting from a search operation with grouping. This class has a derived class GroupingQuery<(Of <(TKey, T>)>) with specific type of the key used for the index search.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class GroupingQuery<T> : IEnumerable<IndexedGroup<T>>,
    IEnumerable
Visual Basic (Declaration)
Public MustInherit Class GroupingQuery(Of T) _
    Implements IEnumerable(Of IndexedGroup(Of T)), IEnumerable

Type Parameters

T
The type of the elements of the indexed collection.

Remarks

The result of any index search operation, IndexQuery<(Of <(T>)>) can be grouped by applying GroupByUntypedKey()()(). It is grouped by the key that was used to perform the search operation. For example,
Copy CodeC#
customers.Indexes(c => c.City).All().GroupByUntypedKey();
customers.Indexes(c => c.City).FindBetween("A", "Z").GroupByUntypedKey();

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.GroupingQuery<(Of <(T>)>)

See Also

GroupingQuery<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(TKey, T>)>)


GroupingQuery(T) Members

[image] [image]

.NET Framework Class Library
GroupingQuery<(Of <(T>)>) Members
GroupingQuery<(Of <(T>)>) Class Methods See Also

The GroupingQuery<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the GroupingQuery<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

GroupingQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GroupingQuery(T) Methods

[image] [image]

.NET Framework Class Library
GroupingQuery<(Of <(T>)>) Methods
GroupingQuery<(Of <(T>)>) Class See Also

The GroupingQuery<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the GroupingQuery<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

GroupingQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
GroupingQuery<(Of <(T>)>)..::.GetEnumerator Method
GroupingQuery<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the GroupingQuery<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerator<IndexedGroup<T>> GetEnumerator()
Visual Basic (Declaration)
Public MustOverride Function GetEnumerator As IEnumerator(Of IndexedGroup(Of T))

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

GroupingQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GroupingQuery(TKey, T) Class

[image]

.NET Framework Class Library
GroupingQuery<(Of <(TKey, T>)>) Class
Members See Also
Represents a collection of IndexedGroup<(Of <(TKey, T>)>), groups of elements with the same key, resulting from a search operation with grouping.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class GroupingQuery<TKey, T> : IEnumerable<IndexedGroup<TKey, T>>,
    IEnumerable
Visual Basic (Declaration)
Public MustInherit Class GroupingQuery(Of TKey, T) _
    Implements IEnumerable(Of IndexedGroup(Of TKey, T)),  _
    IEnumerable

Type Parameters

TKey
The type of the index key.
T
The type of the elements of the indexed collection.

Remarks

The result of any index search operation, IndexQuery<(Of <(T, TKey>)>) can be grouped by applying GroupByKey()()(). It is grouped by the key that was used to perform the search operation. For example,
Copy CodeC#
customers.Indexes(c => c.City).All().GroupByKey();
customers.Indexes(c => c.City).FindBetween("A", "Z").GroupByKey();

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.GroupingQuery<(Of <(TKey, T>)>)

See Also

GroupingQuery<(Of <(TKey, T>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)


GroupingQuery(TKey, T) Members

[image] [image]

.NET Framework Class Library
GroupingQuery<(Of <(TKey, T>)>) Members
GroupingQuery<(Of <(TKey, T>)>) Class Methods See Also

The GroupingQuery<(Of <(TKey, T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the GroupingQuery<(Of <(TKey, T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

GroupingQuery<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GroupingQuery(TKey, T) Methods

[image] [image]

.NET Framework Class Library
GroupingQuery<(Of <(TKey, T>)>) Methods
GroupingQuery<(Of <(TKey, T>)>) Class See Also

The GroupingQuery<(Of <(TKey, T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the GroupingQuery<(Of <(TKey, T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

GroupingQuery<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
GroupingQuery<(Of <(TKey, T>)>)..::.GetEnumerator Method
GroupingQuery<(Of <(TKey, T>)>) Class See Also
Returns an enumerator that iterates through the GroupingQuery<(Of <(TKey, T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerator<IndexedGroup<TKey, T>> GetEnumerator()
Visual Basic (Declaration)
Public MustOverride Function GetEnumerator As IEnumerator(Of IndexedGroup(Of TKey, T))

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

GroupingQuery<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T) Interface

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>) Interface
Members See Also
Represents an index or a subindex in its capacity of scanning through data. Provides methods for searching data items.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public interface IIndexScanner<T>
Visual Basic (Declaration)
Public Interface IIndexScanner(Of T)

Type Parameters

T
The type of the elements of the indexed collection.

Remarks

This interface is implemented by Index<(Of <(T>)>). It is also used by subindexes, but there it is not directly implemented by Subindex<(Of <(T>)>), but rather returned by the IndexQuery<T>.Subindex method because it depends on the item found by an index or a subindex that is the parent of that subindex.

IIndexScanner<(Of <(T>)>) has a typed key counterpart IIndexScanner<(Of <(T, TKey>)>) that is used with typed key classes Index<(Of <(T, TKey>)>) and Subindex<(Of <(T, TKey>)>)

See Also

IIndexScanner<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T) Members

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>) Members
IIndexScanner<(Of <(T>)>) Interface Methods Properties See Also

The IIndexScanner<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
All | Gets all items in the indexed collection.
ContainsKey | Returns a value that indicates whether the collection contains an item with the given key value.
Find | Finds items with the specified key value.
FindBetween | Finds items with key values in the interval between the specified values.
FindGreater | Finds items with keys greater than the specified value.
FindKeys | Finds items containing any of the specified key values.
FindLess | Finds items with keys less than the specified value.
FindStartingWith | Finds items with string key values starting with the specified string.
GroupJoin | Overloaded.
Join | Overloaded.

Properties

Name | Description
Definition | Gets an Index<(Of <(T>)>) or a Subindex<(Of <(T>)>) definition on which the scanner is based.
KeyCount | Gets the number of distinct key values in all items of this collection.
ParentScanner | Gets an index or a subindex scanner that is the parent of a subindex scanner.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T) Methods

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>) Methods
IIndexScanner<(Of <(T>)>) Interface See Also

The IIndexScanner<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
All | Gets all items in the indexed collection.
ContainsKey | Returns a value that indicates whether the collection contains an item with the given key value.
Find | Finds items with the specified key value.
FindBetween | Finds items with key values in the interval between the specified values.
FindGreater | Finds items with keys greater than the specified value.
FindKeys | Finds items containing any of the specified key values.
FindLess | Finds items with keys less than the specified value.
FindStartingWith | Finds items with string key values starting with the specified string.
GroupJoin | Overloaded.
Join | Overloaded.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


All Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.All Method
IIndexScanner<(Of <(T>)>) Interface See Also
Gets all items in the indexed collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> All(
    Order order
)
Visual Basic (Declaration)
Function All ( _
    order As Order _
) As IndexQuery(Of T)

Parameters

order
Type: C1.LiveLinq..::.Order
Specifies the order of the key values to sort the result.

Return Value

An object enumerating all items of the collection in the specified order of their key values.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


ContainsKey Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.ContainsKey Method
IIndexScanner<(Of <(T>)>) Interface See Also
Returns a value that indicates whether the collection contains an item with the given key value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ContainsKey(
    Object key
)
Visual Basic (Declaration)
Function ContainsKey ( _
    key As Object _
) As Boolean

Parameters

key
Type: System..::.Object
The key value to search for

Return Value

true if the collection contains an element with the specified key value; otherwise, false.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


Find Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.Find Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items with the specified key value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> Find(
    Object key
)
Visual Basic (Declaration)
Function Find ( _
    key As Object _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
The key value to search for.

Return Value

An object enumerating items having the specified key value.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


FindBetween Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.FindBetween Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items with key values in the interval between the specified values.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> FindBetween(
    Object min,
    bool minInclusive,
    Object max,
    bool maxInclusive,
    Order order
)
Visual Basic (Declaration)
Function FindBetween ( _
    min As Object, _
    minInclusive As Boolean, _
    max As Object, _
    maxInclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

min
Type: System..::.Object
Minimum key value to search for.
minInclusive
Type: System..::.Boolean
If true, the result includes items with the minimum key value.
max
Type: System..::.Object
Maximum key value to search for.
maxInclusive
Type: System..::.Boolean
If true, the result includes items with the maximum key value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items with key values within the specified limits.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


FindGreater Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.FindGreater Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items with keys greater than the specified value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> FindGreater(
    Object key,
    bool inclusive,
    Order order
)
Visual Basic (Declaration)
Function FindGreater ( _
    key As Object, _
    inclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
Minimum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly greater than the specified value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are greater than the specified value.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


FindKeys Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.FindKeys Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items containing any of the specified key values.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> FindKeys(
    IEnumerable keys,
    Order order
)
Visual Basic (Declaration)
Function FindKeys ( _
    keys As IEnumerable, _
    order As Order _
) As IndexQuery(Of T)

Parameters

keys
Type: System.Collections..::.IEnumerable
The key values to search for.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values belong to the specified key value collection.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


FindLess Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.FindLess Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items with keys less than the specified value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> FindLess(
    Object key,
    bool inclusive,
    Order order
)
Visual Basic (Declaration)
Function FindLess ( _
    key As Object, _
    inclusive As Boolean, _
    order As Order _
) As IndexQuery(Of T)

Parameters

key
Type: System..::.Object
Maximum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly less than the specified value.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are less than the specified value.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


FindStartingWith Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.FindStartingWith Method
IIndexScanner<(Of <(T>)>) Interface See Also
Finds items with string key values starting with the specified string.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, string> FindStartingWith(
    string value,
    Func<string, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Function FindStartingWith ( _
    value As String, _
    keyPredicate As Func(Of String, Boolean), _
    order As Order _
) As IndexQuery(Of T, String)

Parameters

value
Type: System..::.String
The string to search for as the beginning of key value strings.
keyPredicate
Type: System..::.Func <(Of <( String, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are strings that have a beginning matching the specified string and satisfy the optional condition.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


GroupJoin Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.GroupJoin Method
IIndexScanner<(Of <(T>)>) Interface See Also

Overload List

Name | Description
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

See Also

IIndexScanner<(Of <(T>)>) Interface
IIndexScanner<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IIndexScanner(T2), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
IIndexScanner<(Of <(T>)>) Interface See Also
Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IIndexScanner<T2> source,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IIndexScanner(Of T2), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2>)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second collection joined to it.

Remarks

Matching of two elements is performed by matching their keys.

See Also

IIndexScanner<(Of <(T>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(IEnumerable(T), T2, TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order)
IIndexScanner<(Of <(T>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<IEnumerable<T>, T2, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of IEnumerable(Of T), T2, TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( IEnumerable <(Of <( T >)>), T2, TResult>)>)>)>)
A function to create a result element from an element of the second sequence and the collection of matching elements from this collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of the second collection and the corresponding enumeration of the items of this collection joined to it.

See Also

IIndexScanner<(Of <(T>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
IIndexScanner<(Of <(T>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second sequence.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second sequence joined to it.

See Also

IIndexScanner<(Of <(T>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


Join Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.Join Method
IIndexScanner<(Of <(T>)>) Interface See Also

Overload List

Name | Description
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

See Also

IIndexScanner<(Of <(T>)>) Interface
IIndexScanner<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


Join(T2, TResult) Method (IIndexScanner(T2), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.Join<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
IIndexScanner<(Of <(T>)>) Interface See Also
Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> Join<T2, TResult>(
    IIndexScanner<T2> source,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Function Join(Of T2, TResult) ( _
    source As IIndexScanner(Of T2), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2>)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

Remarks

Matching of two elements is performed by matching their keys.

See Also

IIndexScanner<(Of <(T>)>) Interface
Join Overload
C1.LiveLinq.Indexing.Search Namespace


Join(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, Object)), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.Join<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
IIndexScanner<(Of <(T>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> Join<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, Object>> keySelector,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Function Join(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, Object)), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, Object >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

See Also

IIndexScanner<(Of <(T>)>) Interface
Join Overload
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T) Properties

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>) Properties
IIndexScanner<(Of <(T>)>) Interface See Also

The IIndexScanner<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Definition | Gets an Index<(Of <(T>)>) or a Subindex<(Of <(T>)>) definition on which the scanner is based.
KeyCount | Gets the number of distinct key values in all items of this collection.
ParentScanner | Gets an index or a subindex scanner that is the parent of a subindex scanner.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


Definition Property

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.Definition Property
IIndexScanner<(Of <(T>)>) Interface See Also
Gets an Index<(Of <(T>)>) or a Subindex<(Of <(T>)>) definition on which the scanner is based.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexDefinition<T> Definition { get; }
Visual Basic (Declaration)
ReadOnly Property Definition As IndexDefinition(Of T)

Field Value

For a subindex scanner, returns a Subindex<(Of <(T>)>). For an index scanner, returns the same Index<(Of <(T>)>) object as the scanner itself.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


KeyCount Property

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.KeyCount Property
IIndexScanner<(Of <(T>)>) Interface See Also
Gets the number of distinct key values in all items of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int KeyCount { get; }
Visual Basic (Declaration)
ReadOnly Property KeyCount As Integer

Field Value

Number of distinct key values in the collection.

Remarks

This number is not the same as the number of elements in the collection, unless the index key is a unique key of that collection, see KeyIsUnique.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


ParentScanner Property

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T>)>)..::.ParentScanner Property
IIndexScanner<(Of <(T>)>) Interface See Also
Gets an index or a subindex scanner that is the parent of a subindex scanner.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IIndexScanner<T> ParentScanner { get; }
Visual Basic (Declaration)
ReadOnly Property ParentScanner As IIndexScanner(Of T)

Field Value

Parent scanner for a subindex scanner; null for an index scanner.

See Also

IIndexScanner<(Of <(T>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T, TKey) Interface

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>) Interface
Members See Also
Represents an index or a subindex in its capacity of scanning through data. Provides methods for searching data items.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public interface IIndexScanner<T, TKey> : IIndexScanner<T>
Visual Basic (Declaration)
Public Interface IIndexScanner(Of T, TKey) _
    Implements IIndexScanner(Of T)

Type Parameters

T
The type of the elements of the indexed collection.
TKey
The type of the index key.

Remarks

This interface is implemented by Index<(Of <(T, TKey>)>). It is also used by subindexes, but there it is not directly implemented by Subindex<(Of <(T, TKey>)>), but rather returned by the IndexQuery<T>.Subindex method because it depends on the item found by an index or a subindex that is the parent of that subindex.

IIndexScanner<(Of <(T, TKey>)>) has an untyped key counterpart IIndexScanner<(Of <(T>)>) that is used with untyped key classes Index<(Of <(T>)>) and Subindex<(Of <(T>)>)

See Also

IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T, TKey) Members

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>) Members
IIndexScanner<(Of <(T, TKey>)>) Interface Methods Properties See Also

The IIndexScanner<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
All | Overloaded.
ContainsKey | Overloaded.
Find | Overloaded.
FindBetween | Overloaded.
FindGreater | Overloaded.
FindKeys | Overloaded.
FindLess | Overloaded.
FindStartingWith | Finds items with string key values starting with the specified string. (Inherited from IIndexScanner<(Of <(T>)>).)
GroupJoin | Overloaded.
Join | Overloaded.
Keys | Gets distinct key values in all items of this collection.

Properties

Name | Description
Definition | Gets an Index<(Of <(T>)>) or a Subindex<(Of <(T>)>) definition on which the scanner is based. (Inherited from IIndexScanner<(Of <(T>)>).)
KeyCount | Gets the number of distinct key values in all items of this collection. (Inherited from IIndexScanner<(Of <(T>)>).)
ParentScanner | Gets an index or a subindex scanner that is the parent of a subindex scanner. (Inherited from IIndexScanner<(Of <(T>)>).)

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T, TKey) Methods

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>) Methods
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

The IIndexScanner<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
All | Overloaded.
ContainsKey | Overloaded.
Find | Overloaded.
FindBetween | Overloaded.
FindGreater | Overloaded.
FindKeys | Overloaded.
FindLess | Overloaded.
FindStartingWith | Finds items with string key values starting with the specified string. (Inherited from IIndexScanner<(Of <(T>)>).)
GroupJoin | Overloaded.
Join | Overloaded.
Keys | Gets distinct key values in all items of this collection.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


All Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.All Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
All(Order) | Gets all items in the indexed collection. (Inherited from IIndexScanner<(Of <(T>)>).)
All(Order) | Gets all items in the indexed collection.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


All Method (Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.All Method (Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Gets all items in the indexed collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> All(
    Order order
)
Visual Basic (Declaration)
Function All ( _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

order
Type: C1.LiveLinq..::.Order
Specifies the order of the key values to sort the result.

Return Value

All items of the collection in the specified order of their key values.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
All Overload
C1.LiveLinq.Indexing.Search Namespace


ContainsKey Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.ContainsKey Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
ContainsKey(Object) | Returns a value that indicates whether the collection contains an item with the given key value. (Inherited from IIndexScanner<(Of <(T>)>).)
ContainsKey(TKey) | Returns a value that indicates whether the collection contains an item with the given key value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


ContainsKey Method (TKey)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.ContainsKey Method (TKey)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Returns a value that indicates whether the collection contains an item with the given key value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ContainsKey(
    TKey key
)
Visual Basic (Declaration)
Function ContainsKey ( _
    key As TKey _
) As Boolean

Parameters

key
Type: TKey
The key value to search for

Return Value

true if the collection contains an element with the specified key value; otherwise, false.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
ContainsKey Overload
C1.LiveLinq.Indexing.Search Namespace


Find Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Find Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
Find(Object) | Finds items with the specified key value. (Inherited from IIndexScanner<(Of <(T>)>).)
Find(TKey) | Finds items with the specified key value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


Find Method (TKey)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Find Method (TKey)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Finds items with the specified key value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> Find(
    TKey key
)
Visual Basic (Declaration)
Function Find ( _
    key As TKey _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
The key value to search for.

Return Value

An object enumerating items having the specified key value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
Find Overload
C1.LiveLinq.Indexing.Search Namespace


FindBetween Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindBetween Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
FindBetween(Object, Boolean, Object, Boolean, Order) | Finds items with key values in the interval between the specified values. (Inherited from IIndexScanner<(Of <(T>)>).)
FindBetween(TKey, Boolean, TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with key values in the interval between the specified values.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


FindBetween Method (TKey, Boolean, TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindBetween Method (TKey, Boolean, TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Finds items with key values in the interval between the specified values.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> FindBetween(
    TKey min,
    bool minInclusive,
    TKey max,
    bool maxInclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Function FindBetween ( _
    min As TKey, _
    minInclusive As Boolean, _
    max As TKey, _
    maxInclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

min
Type: TKey
Minimum key value to search for.
minInclusive
Type: System..::.Boolean
If true, the result includes items with the minimum key value.
max
Type: TKey
Maximum key value to search for.
maxInclusive
Type: System..::.Boolean
If true, the result includes items with the maximum key value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items with key values within the specified limits.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
FindBetween Overload
C1.LiveLinq.Indexing.Search Namespace


FindGreater Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindGreater Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
FindGreater(Object, Boolean, Order) | Finds items with keys greater than the specified value. (Inherited from IIndexScanner<(Of <(T>)>).)
FindGreater(TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with keys greater than the specified value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


FindGreater Method (TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindGreater Method (TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Finds items with keys greater than the specified value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> FindGreater(
    TKey key,
    bool inclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Function FindGreater ( _
    key As TKey, _
    inclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
Minimum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly greater than the specified value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are greater than the specified value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
FindGreater Overload
C1.LiveLinq.Indexing.Search Namespace


FindKeys Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindKeys Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
FindKeys(IEnumerable, Order) | Finds items containing any of the specified key values. (Inherited from IIndexScanner<(Of <(T>)>).)
FindKeys(IEnumerable<(Of <(TKey>)>), Order) | Finds items containing any of the specified key values.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


FindKeys Method (IEnumerable(TKey), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindKeys Method (IEnumerable<(Of <(TKey>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Finds items containing any of the specified key values.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> FindKeys(
    IEnumerable<TKey> keys,
    Order order
)
Visual Basic (Declaration)
Function FindKeys ( _
    keys As IEnumerable(Of TKey), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

keys
Type: System.Collections.Generic..::.IEnumerable <(Of <( TKey >)>)
The key values to search for.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values belong to the specified key value collection.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
FindKeys Overload
C1.LiveLinq.Indexing.Search Namespace


FindLess Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindLess Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
FindLess(Object, Boolean, Order) | Finds items with keys less than the specified value. (Inherited from IIndexScanner<(Of <(T>)>).)
FindLess(TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order) | Finds items with keys less than the specified value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


FindLess Method (TKey, Boolean, Func(TKey, Boolean), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.FindLess Method (TKey, Boolean, Func<(Of <(TKey, Boolean>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Finds items with keys less than the specified value.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T, TKey> FindLess(
    TKey key,
    bool inclusive,
    Func<TKey, bool> keyPredicate,
    Order order
)
Visual Basic (Declaration)
Function FindLess ( _
    key As TKey, _
    inclusive As Boolean, _
    keyPredicate As Func(Of TKey, Boolean), _
    order As Order _
) As IndexQuery(Of T, TKey)

Parameters

key
Type: TKey
Maximum key value to search for.
inclusive
Type: System..::.Boolean
If true, the result includes items with the specified key value. Otherwise, the result only includes those with keys strictly less than the specified value.
keyPredicate
Type: System..::.Func <(Of <( TKey, Boolean >)>)
An optional condition that found items must satisfy.
order
Type: C1.LiveLinq..::.Order
Optionally specifies the order of the key values to sort the result (Order.Unordered if sorting is not required).

Return Value

An object enumerating all items whose key values are less than the specified value.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
FindLess Overload
C1.LiveLinq.Indexing.Search Namespace


GroupJoin Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.GroupJoin Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) |
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection. (Inherited from IIndexScanner<(Of <(T>)>).)
GroupJoin<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence. (Inherited from IIndexScanner<(Of <(T>)>).)
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.
GroupJoin<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order) | Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IIndexScanner(T2, TKey), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Correlates the items of this indexed collection with the items of another indexed collection and groups the results by the item of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IIndexScanner<T2, TKey> source,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IIndexScanner(Of T2, TKey), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2, TKey >)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second collection joined to it.

Remarks

Matching of two elements is performed by matching their keys.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(IEnumerable(T), T2, TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(IEnumerable<(Of <(T>)>), T2, TResult>)>)>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of the second sequence.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<IEnumerable<T>, T2, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of IEnumerable(Of T), T2, TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( IEnumerable <(Of <( T >)>), T2, TResult>)>)>)>)
A function to create a result element from an element of the second sequence and the collection of matching elements from this collection.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of the second collection and the corresponding enumeration of the items of this collection joined to it.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


GroupJoin(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(T, IEnumerable(T2), TResult)), Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.GroupJoin<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, IEnumerable<(Of <(T2>)>), TResult>)>)>)>), Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and groups the results by the item of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> GroupJoin<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<T, IEnumerable<T2>, TResult>> resultSelector,
    Order keyOrder
)
Visual Basic (Declaration)
Function GroupJoin(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of T, IEnumerable(Of T2), TResult)), _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IEnumerable <(Of <(T2>)>), TResult>)>)>)>)
A function to create a result element from an element from this collection and a collection of matching elements from the second sequence.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to group pairs, where each pair consists of an item of this collection and the corresponding enumeration of the items of the second sequence joined to it.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
GroupJoin Overload
C1.LiveLinq.Indexing.Search Namespace


Join Method

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Join Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

Overload List

Name | Description
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys. (Inherited from IIndexScanner<(Of <(T>)>).)
Join<(Of <(T2, TResult>)>)(IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, Object>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys. (Inherited from IIndexScanner<(Of <(T>)>).)
Join<(Of <(T2, TResult>)>)(IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order) | Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
IIndexScanner<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


Join(T2, TResult) Method (IIndexScanner(T2, TKey), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Join<(Of <(T2, TResult>)>) Method (IIndexScanner<(Of <(T2, TKey>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Correlates the items of this indexed collection with the items of another indexed collection and returns the combined items with matching keys.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> Join<T2, TResult>(
    IIndexScanner<T2, TKey> source,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Function Join(Of T2, TResult) ( _
    source As IIndexScanner(Of T2, TKey), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <(T2, TKey >)>)
The second indexed collection to join to this collection.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second collection.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

Remarks

Matching of two elements is performed by matching their keys.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
Join Overload
C1.LiveLinq.Indexing.Search Namespace


Join(T2, TResult) Method (IEnumerable(T2), Expression(Func(T2, TKey)), Expression(Func(T, T2, TResult)), JoinOperator, Order)

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Join<(Of <(T2, TResult>)>) Method (IEnumerable<(Of <(T2>)>), Expression<(Of <(Func<(Of <(T2, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, T2, TResult>)>)>)>), JoinOperator, Order)
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Correlates the items of this indexed collection with the items of another sequence and returns the combined items with matching keys.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TResult> Join<T2, TResult>(
    IEnumerable<T2> source,
    Expression<Func<T2, TKey>> keySelector,
    Expression<Func<T, T2, TResult>> resultSelector,
    JoinOperator op,
    Order keyOrder
)
Visual Basic (Declaration)
Function Join(Of T2, TResult) ( _
    source As IEnumerable(Of T2), _
    keySelector As Expression(Of Func(Of T2, TKey)), _
    resultSelector As Expression(Of Func(Of T, T2, TResult)), _
    op As JoinOperator, _
    keyOrder As Order _
) As IEnumerable(Of TResult)

Parameters

source
Type: System.Collections.Generic..::.IEnumerable <(Of <(T2>)>)
The second sequence to join to this collection.
keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(T2, TKey >)>)>)>)
A function to extract from an item of the second sequence the value to match against this collection's key value.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, T2, TResult>)>)>)>)
A function to create a result element from two matching elements.
op
Type: C1.LiveLinq.Indexing.Search..::.JoinOperator
A comparison operator to match elements.
keyOrder
Type: C1.LiveLinq..::.Order
Required ordering of the result collection.

Type Parameters

T2
The type of the elements of the second sequence.
TResult
The type of the result elements.

Return Value

Enumeration of objects obtained by applying the result selector to pairs of joined elements of the two collections.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
Join Overload
C1.LiveLinq.Indexing.Search Namespace


Keys Method

[image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>)..::.Keys Method
IIndexScanner<(Of <(T, TKey>)>) Interface See Also
Gets distinct key values in all items of this collection.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerable<TKey> Keys(
    Order order
)
Visual Basic (Declaration)
Function Keys ( _
    order As Order _
) As IEnumerable(Of TKey)

Parameters

order
Type: C1.LiveLinq..::.Order
Specifies the order of the key values to sort the result.

Return Value

All distinct key values contained in the items of the collection in the specified order.

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


IIndexScanner(T, TKey) Properties

[image] [image]

.NET Framework Class Library
IIndexScanner<(Of <(T, TKey>)>) Properties
IIndexScanner<(Of <(T, TKey>)>) Interface See Also

The IIndexScanner<(Of <(T, TKey>)>) type exposes the following members.

Properties

Name | Description
Definition | Gets an Index<(Of <(T>)>) or a Subindex<(Of <(T>)>) definition on which the scanner is based. (Inherited from IIndexScanner<(Of <(T>)>).)
KeyCount | Gets the number of distinct key values in all items of this collection. (Inherited from IIndexScanner<(Of <(T>)>).)
ParentScanner | Gets an index or a subindex scanner that is the parent of a subindex scanner. (Inherited from IIndexScanner<(Of <(T>)>).)

See Also

IIndexScanner<(Of <(T, TKey>)>) Interface
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(T) Class

[image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>) Class
Members See Also
Represents a group of elements with the same key belonging to a collection of groups resulting from a search operation with grouping. This class has a derived class IndexedGroup<(Of <(TKey, T>)>) with specific key type.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexedGroup<T> : IndexQuery<T>,
    IGrouping<Object, T>, IEnumerable<T>, IEnumerable
Visual Basic (Declaration)
Public MustInherit Class IndexedGroup(Of T) _
    Inherits IndexQuery(Of T) _
    Implements IGrouping(Of Object, T), IEnumerable(Of T),  _
    IEnumerable

Type Parameters

T
The type of the elements of the indexed collection.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.IndexQuery <(Of <( T >)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(TKey, T>)>)

See Also

IndexedGroup<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.GroupingQuery<(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(TKey, T>)>)


IndexedGroup(T) Members

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>) Members
IndexedGroup<(Of <(T>)>) Class Methods Properties See Also

The IndexedGroup<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key. (Inherited from IndexQuery<(Of <(T>)>).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
Key | Gets the key of the IndexedGroup<(Of <(T>)>).
KeyType | Gets the type of the key of the IndexedGroup<(Of <(T>)>).

See Also

IndexedGroup<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(T) Methods

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>) Methods
IndexedGroup<(Of <(T>)>) Class See Also

The IndexedGroup<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key. (Inherited from IndexQuery<(Of <(T>)>).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexedGroup<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


Subindex Method

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>)..::.Subindex Method
IndexedGroup<(Of <(T>)>) Class See Also

Overload List

Name | Description
Subindex(Subindex<(Of <(T>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)
Subindex<(Of <(TKey>)>)(Subindex<(Of <(T, TKey>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)

See Also

IndexedGroup<(Of <(T>)>) Class
IndexedGroup<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(T) Properties

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>) Properties
IndexedGroup<(Of <(T>)>) Class See Also

The IndexedGroup<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
Key | Gets the key of the IndexedGroup<(Of <(T>)>).
KeyType | Gets the type of the key of the IndexedGroup<(Of <(T>)>).

See Also

IndexedGroup<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


Key Property

[image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>)..::.Key Property
IndexedGroup<(Of <(T>)>) Class See Also
Gets the key of the IndexedGroup<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Object Key { get; }
Visual Basic (Declaration)
Public ReadOnly Property Key As Object

Return Value

The key of the IndexedGroup<(Of <(T>)>).

Implements

IGrouping<(Of <(TKey, TElement>)>)..::.Key

See Also

IndexedGroup<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


KeyType Property

[image]

.NET Framework Class Library
IndexedGroup<(Of <(T>)>)..::.KeyType Property
IndexedGroup<(Of <(T>)>) Class See Also
Gets the type of the key of the IndexedGroup<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract Type KeyType { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property KeyType As Type

Return Value

Type of the key of the IndexedGroup<(Of <(T>)>).

See Also

IndexedGroup<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(TKey, T) Class

[image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>) Class
Members See Also
Represents a group of elements with the same key belonging to a collection of groups resulting from a search operation with grouping.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexedGroup<TKey, T> : IndexedGroup<T>,
    IGrouping<TKey, T>, IEnumerable<TKey>, IEnumerable
Visual Basic (Declaration)
Public MustInherit Class IndexedGroup(Of TKey, T) _
    Inherits IndexedGroup(Of T) _
    Implements IGrouping(Of TKey, T), IEnumerable(Of TKey),  _
    IEnumerable

Type Parameters

TKey
The type of the index key.
T
The type of the elements of the indexed collection.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.IndexQuery <(Of <( T >)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup <(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(TKey, T>)>)

See Also

IndexedGroup<(Of <(TKey, T>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.GroupingQuery<(Of <(TKey, T>)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)


IndexedGroup(TKey, T) Members

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>) Members
IndexedGroup<(Of <(TKey, T>)>) Class Methods Properties See Also

The IndexedGroup<(Of <(TKey, T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key. (Inherited from IndexQuery<(Of <(T>)>).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
Key | Gets the key of the IndexedGroup<(Of <(TKey, T>)>).
KeyType | Gets the type of the key of the IndexedGroup<(Of <(TKey, T>)>). (Overrides IndexedGroup<(Of <(T>)>)..::.KeyType.)

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(TKey, T) Methods

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>) Methods
IndexedGroup<(Of <(TKey, T>)>) Class See Also

The IndexedGroup<(Of <(TKey, T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key. (Inherited from IndexQuery<(Of <(T>)>).)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


Subindex Method

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>)..::.Subindex Method
IndexedGroup<(Of <(TKey, T>)>) Class See Also

Overload List

Name | Description
Subindex(Subindex<(Of <(T>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)
Subindex<(Of <(TKey>)>)(Subindex<(Of <(T, TKey>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
IndexedGroup<(Of <(TKey, T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


IndexedGroup(TKey, T) Properties

[image] [image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>) Properties
IndexedGroup<(Of <(TKey, T>)>) Class See Also

The IndexedGroup<(Of <(TKey, T>)>) type exposes the following members.

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
Key | Gets the key of the IndexedGroup<(Of <(TKey, T>)>).
KeyType | Gets the type of the key of the IndexedGroup<(Of <(TKey, T>)>). (Overrides IndexedGroup<(Of <(T>)>)..::.KeyType.)

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


Key Property

[image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>)..::.Key Property
IndexedGroup<(Of <(TKey, T>)>) Class See Also
Gets the key of the IndexedGroup<(Of <(TKey, T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract TKey Key { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property Key As TKey

Return Value

The key of the IndexedGroup<(Of <(TKey, T>)>).

Implements

IGrouping<(Of <(TKey, TElement>)>)..::.Key

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


KeyType Property

[image]

.NET Framework Class Library
IndexedGroup<(Of <(TKey, T>)>)..::.KeyType Property
IndexedGroup<(Of <(TKey, T>)>) Class See Also
Gets the type of the key of the IndexedGroup<(Of <(TKey, T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override sealed Type KeyType { get; }
Visual Basic (Declaration)
Public Overrides NotOverridable ReadOnly Property KeyType As Type

Return Value

The same type as the TKey type parameter of the class.

See Also

IndexedGroup<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T) Class

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>) Class
Members See Also
Represents a collection that is the result of an index search. Objects of this class are returned by the IIndexScanner<(Of <(T>)>) search methods. This class has a derived class IndexQuery<(Of <(T, TKey>)>) with specific type of the key used for the index search.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexQuery<T> : IIndexedSource<T>,
    IEnumerable<T>, IEnumerable
Visual Basic (Declaration)
Public MustInherit Class IndexQuery(Of T) _
    Implements IIndexedSource(Of T), IEnumerable(Of T),  _
    IEnumerable

Type Parameters

T
The type of the elements of the indexed collection.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.IndexQuery<(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexQuery<(Of <(T, TKey>)>)

See Also

IndexQuery<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexQuery<(Of <(T, TKey>)>)


IndexQuery(T) Members

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>) Members
IndexQuery<(Of <(T>)>) Class Methods Properties See Also

The IndexQuery<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>).

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T) Methods

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>) Methods
IndexQuery<(Of <(T>)>) Class See Also

The IndexQuery<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByUntypedKey | Groups the collection of search results by its search key.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.GetEnumerator Method
IndexQuery<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract IEnumerator<T> GetEnumerator()
Visual Basic (Declaration)
Public MustOverride Function GetEnumerator As IEnumerator(Of T)

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GroupByUntypedKey Method

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.GroupByUntypedKey Method
IndexQuery<(Of <(T>)>) Class See Also
Groups the collection of search results by its search key.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual GroupingQuery<T> GroupByUntypedKey()
Visual Basic (Declaration)
Public Overridable Function GroupByUntypedKey As GroupingQuery(Of T)

Return Value

Search result collection grouped by its search key.

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)
IndexQuery<(Of <(T, TKey>)>)..::.GroupByKey()()()


Subindex Method

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.Subindex Method
IndexQuery<(Of <(T>)>) Class See Also

Overload List

Name | Description
Subindex(Subindex<(Of <(T>)>)) | Used to apply subindex search to the result of a search operation.
Subindex<(Of <(TKey>)>)(Subindex<(Of <(T, TKey>)>)) | Used to apply subindex search to the result of a search operation.

See Also

IndexQuery<(Of <(T>)>) Class
IndexQuery<(Of <(T>)>) Members
C1.LiveLinq.Indexing.Search Namespace


Subindex Method (Subindex(T))

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.Subindex Method (Subindex<(Of <(T>)>))
IndexQuery<(Of <(T>)>) Class See Also
Used to apply subindex search to the result of a search operation.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IIndexScanner<T> Subindex(
    Subindex<T> definition
)
Visual Basic (Declaration)
Public Function Subindex ( _
    definition As Subindex(Of T) _
) As IIndexScanner(Of T)

Parameters

definition
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)
Subindex to use for narrowing the search.

Return Value

An IIndexScanner<(Of <(T>)>) collection indexed by the subindex that can be used to perform search operations narrowing the collection.

Remarks

A subindex can be used to further narrow the result of a search operation, if the corresponding subindex exists in the index or subindex used to perform that search operation. For example,
Copy CodeC#
var idxByCity = customers.Indexes(c => c.City);
var subindexByContactTitle = idxByCity.Subindexes(c => c.ContactTitle);
var ownersInLondon = idxByCity.Find("London").Subindex<string>(subindexByContactTitle).Find("Owner");

See Also

IndexQuery<(Of <(T>)>) Class
Subindex Overload
C1.LiveLinq.Indexing.Search Namespace


Subindex(TKey) Method (Subindex(T, TKey))

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.Subindex<(Of <(TKey>)>) Method (Subindex<(Of <(T, TKey>)>))
IndexQuery<(Of <(T>)>) Class See Also
Used to apply subindex search to the result of a search operation.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual IIndexScanner<T, TKey> Subindex<TKey>(
    Subindex<T, TKey> definition
)
Visual Basic (Declaration)
Public Overridable Function Subindex(Of TKey) ( _
    definition As Subindex(Of T, TKey) _
) As IIndexScanner(Of T, TKey)

Parameters

definition
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T, TKey>)>)
Subindex to use for narrowing the search.

Type Parameters

TKey
Type of the subindex key.

Return Value

An IIndexScanner<(Of <(T, TKey>)>) collection indexed by the subindex that can be used to perform search operations narrowing the collection.

Remarks

A subindex can be used to further narrow the result of a search operation, if the corresponding subindex exists in the index or subindex used to perform that search operation. For example,
Copy CodeC#
var idxByCity = customers.Indexes(c => c.City);
var subindexByContactTitle = idxByCity.Subindexes(c => c.ContactTitle);
var ownersInLondon = idxByCity.Find("London").Subindex(subindexByContactTitle).Find("Owner");

See Also

IndexQuery<(Of <(T>)>) Class
Subindex Overload
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T) Properties

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>) Properties
IndexQuery<(Of <(T>)>) Class See Also

The IndexQuery<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>).

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


Indexes Property

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.Indexes Property
IndexQuery<(Of <(T>)>) Class See Also
The collection of subindexes for this IndexQuery<(Of <(T>)>).

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ScannerCollection<T> Indexes { get; }
Visual Basic (Declaration)
Public ReadOnly Property Indexes As ScannerCollection(Of T)

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T, TKey) Class

[image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>) Class
Members See Also
Represents a collection that is the result of an index search. Objects of this class are returned by the IIndexScanner<(Of <(T, TKey>)>) search methods.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class IndexQuery<T, TKey> : IndexQuery<T>
Visual Basic (Declaration)
Public MustInherit Class IndexQuery(Of T, TKey) _
    Inherits IndexQuery(Of T)

Type Parameters

T
The type of the elements of the indexed collection.
TKey
The type of the index key.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Indexing.Search..::.IndexQuery <(Of <(T>)>)
C1.LiveLinq.Indexing.Search..::.IndexQuery<(Of <(T, TKey>)>)

See Also

IndexQuery<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexQuery<(Of <(T>)>)


IndexQuery(T, TKey) Members

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>) Members
IndexQuery<(Of <(T, TKey>)>) Class Methods Properties See Also

The IndexQuery<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByKey | Groups the collection of search results by its search key.
GroupByUntypedKey | Groups the collection of search results by its search key. (Overrides IndexQuery<(Of <(T>)>)..::.GroupByUntypedKey()()().)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)

See Also

IndexQuery<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T, TKey) Methods

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>) Methods
IndexQuery<(Of <(T, TKey>)>) Class See Also

The IndexQuery<(Of <(T, TKey>)>) type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupByKey | Groups the collection of search results by its search key.
GroupByUntypedKey | Groups the collection of search results by its search key. (Overrides IndexQuery<(Of <(T>)>)..::.GroupByUntypedKey()()().)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Subindex | Overloaded.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexQuery<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing.Search Namespace


GroupByKey Method

[image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>)..::.GroupByKey Method
IndexQuery<(Of <(T, TKey>)>) Class See Also
Groups the collection of search results by its search key.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual GroupingQuery<TKey, T> GroupByKey()
Visual Basic (Declaration)
Public Overridable Function GroupByKey As GroupingQuery(Of TKey, T)

Return Value

Search result collection grouped by its search key.

See Also

IndexQuery<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(TKey, T>)>)
IndexQuery<(Of <(T>)>)..::.GroupByUntypedKey()()()


GroupByUntypedKey Method

[image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>)..::.GroupByUntypedKey Method
IndexQuery<(Of <(T, TKey>)>) Class See Also
Groups the collection of search results by its search key.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override sealed GroupingQuery<T> GroupByUntypedKey()
Visual Basic (Declaration)
Public Overrides NotOverridable Function GroupByUntypedKey As GroupingQuery(Of T)

Return Value

Search result collection grouped by its search key.

See Also

IndexQuery<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing.Search Namespace
C1.LiveLinq.Indexing.Search..::.IndexedGroup<(Of <(T>)>)
IndexQuery<(Of <(T, TKey>)>)..::.GroupByKey()()()


Subindex Method

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>)..::.Subindex Method
IndexQuery<(Of <(T, TKey>)>) Class See Also

Overload List

Name | Description
Subindex(Subindex<(Of <(T>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)
Subindex<(Of <(TKey>)>)(Subindex<(Of <(T, TKey>)>)) | Used to apply subindex search to the result of a search operation. (Inherited from IndexQuery<(Of <(T>)>).)

See Also

IndexQuery<(Of <(T, TKey>)>) Class
IndexQuery<(Of <(T, TKey>)>) Members
C1.LiveLinq.Indexing.Search Namespace


IndexQuery(T, TKey) Properties

[image] [image]

.NET Framework Class Library
IndexQuery<(Of <(T, TKey>)>) Properties
IndexQuery<(Of <(T, TKey>)>) Class See Also

The IndexQuery<(Of <(T, TKey>)>) type exposes the following members.

Properties

Name | Description
Indexes | The collection of subindexes for this IndexQuery<(Of <(T>)>). (Inherited from IndexQuery<(Of <(T>)>).)

See Also

IndexQuery<(Of <(T, TKey>)>) Class
C1.LiveLinq.Indexing.Search Namespace


JoinOperator Enumeration

[image]

.NET Framework Class Library
JoinOperator Enumeration
See Also
A comparison operator to match elements in a join operation.

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum JoinOperator
Visual Basic (Declaration)
Public Enumeration JoinOperator

Members

Member name | Description
Equal | a is equal to b (a == b)
Less | a is less than b (a < b)
LessOrEqual | a is less than or equal to b (a <= b)
Greater | a is greater than b (a > b)
GreaterOrEqual | a is greater than or equal to b (a >= b)

See Also

C1.LiveLinq.Indexing.Search Namespace


C1.LiveLinq.AdoNet Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.AdoNet Namespace

Classes

Class | Description
AdoNetExtensions | Provides a set of static (extension) methods for LiveLinq to DataSet.
IndexedDataTable<(Of <(TRow>)>) | A wrapper for the standard ADO.NET DataTable class allowing to use ADO.NET data sources in LiveLinq indexing and live views.


AdoNetExtensions Class

[image]

.NET Framework Class Library
AdoNetExtensions Class
Members See Also
Provides a set of static (extension) methods for LiveLinq to DataSet.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class AdoNetExtensions
Visual Basic (Declaration)
Public NotInheritable Class AdoNetExtensions

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.AdoNet..::.AdoNetExtensions

See Also

AdoNetExtensions Members
C1.LiveLinq.AdoNet Namespace


AdoNetExtensions Members

[image] [image]

.NET Framework Class Library
AdoNetExtensions Members
AdoNetExtensions Class Methods See Also

The AdoNetExtensions type exposes the following members.

Methods

Name | Description
AsIndexed | Overloaded.
AsLive | Overloaded.
BeginUpdate | Indicates that massive changes are being made in code, until EndUpdate(DataSet), to data tables in this DataSet.
EndUpdate | Indicates the end of massive changes to data tables in this DataSet started with BeginUpdate(DataSet).
IndexedField | Overloaded.

See Also

AdoNetExtensions Class
C1.LiveLinq.AdoNet Namespace


AdoNetExtensions Methods

[image] [image]

.NET Framework Class Library
AdoNetExtensions Methods
AdoNetExtensions Class See Also

The AdoNetExtensions type exposes the following members.

Methods

Name | Description
AsIndexed | Overloaded.
AsLive | Overloaded.
BeginUpdate | Indicates that massive changes are being made in code, until EndUpdate(DataSet), to data tables in this DataSet.
EndUpdate | Indicates the end of massive changes to data tables in this DataSet started with BeginUpdate(DataSet).
IndexedField | Overloaded.

See Also

AdoNetExtensions Class
C1.LiveLinq.AdoNet Namespace


AsIndexed Method

[image] [image]

.NET Framework Class Library
AdoNetExtensions..::.AsIndexed Method
AdoNetExtensions Class See Also

Overload List

Name | Description
AsIndexed(DataTable) | Wraps a DataTable in an IndexedDataTable<DataRow> so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.
AsIndexed<(Of <(TRow>)>)(DataTable) | Wraps a DataTable in an IndexedDataTable<(Of <(TRow>)>) so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.
AsIndexed<(Of <(TRow>)>)(TypedTableBase<(Of <(TRow>)>)) | Wraps a typed ADO.NET data table in an IndexedDataTable<(Of <(TRow>)>) so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.

See Also

AdoNetExtensions Class
AdoNetExtensions Members
C1.LiveLinq.AdoNet Namespace


AsIndexed Method (DataTable)

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsIndexed Method (DataTable)
AdoNetExtensions Class See Also
Wraps a DataTable in an IndexedDataTable<DataRow> so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedDataTable<DataRow> AsIndexed(
    DataTable table
)
Visual Basic (Declaration)
Public Shared Function AsIndexed ( _
    table As DataTable _
) As IndexedDataTable(Of DataRow)

Parameters

table
Type: System.Data..::.DataTable
A DataTable to represent as an IndexedDataTable<DataRow>.

Return Value

An IndexedDataTable<DataRow> that contains the same rows as table and enables indexing of its rows.

Remarks

Use this method to index ADO.NET data tables and query them using the query operators optimized with indexing.

Elements of the source data table aren't duplicated or copied to a new collection. This method just wraps the original data table in an IndexedDataTable<DataRow>.

Note: The IndexedDataTable<DataRow> wrapper is owned by the original DataTable object (in fact, it is stored in its ExtendedProperties). So, if you create a wrapper for the same data table several times, it will be the same object.

See Also

AdoNetExtensions Class
AsIndexed Overload
C1.LiveLinq.AdoNet Namespace


AsIndexed(TRow) Method (DataTable)

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsIndexed<(Of <(TRow>)>) Method (DataTable)
AdoNetExtensions Class See Also
Wraps a DataTable in an IndexedDataTable<(Of <(TRow>)>) so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedDataTable<TRow> AsIndexed<TRow>(
    DataTable table
)
where TRow : DataRow
Visual Basic (Declaration)
Public Shared Function AsIndexed(Of TRow As DataRow) ( _
    table As DataTable _
) As IndexedDataTable(Of TRow)

Parameters

table
Type: System.Data..::.DataTable
A DataTable to represent as an IndexedDataTable<(Of <(TRow>)>).

Type Parameters

TRow
The type of the rows in the table.

Return Value

An IndexedDataTable<(Of <(TRow>)>) that contains the same rows as table and enables indexing of its rows.

Remarks

Use this method to index ADO.NET data tables and query them using the query operators optimized with indexing.

Elements of the source data table aren't duplicated or copied to a new collection. This method just wraps the original data table in an IndexedDataTable<(Of <(TRow>)>).

Note: The IndexedDataTable<(Of <(TRow>)>) wrapper is owned by the original DataTable object (in fact, it is stored in its ExtendedProperties). So, if you create a wrapper for the same data table several times, it will be the same object.

See Also

AdoNetExtensions Class
AsIndexed Overload
C1.LiveLinq.AdoNet Namespace


AsIndexed(TRow) Method (TypedTableBase(TRow))

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsIndexed<(Of <(TRow>)>) Method (TypedTableBase<(Of <(TRow>)>))
AdoNetExtensions Class See Also
Wraps a typed ADO.NET data table in an IndexedDataTable<(Of <(TRow>)>) so it can be indexed and queried using the optimized query operators from IndexedQueryExtensions.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedDataTable<TRow> AsIndexed<TRow>(
    TypedTableBase<TRow> table
)
where TRow : DataRow
Visual Basic (Declaration)
Public Shared Function AsIndexed(Of TRow As DataRow) ( _
    table As TypedTableBase(Of TRow) _
) As IndexedDataTable(Of TRow)

Parameters

table
Type: System.Data..::.TypedTableBase <(Of <(TRow>)>)
A typed data table to represent as an IndexedDataTable<(Of <(TRow>)>).

Type Parameters

TRow
The type of the rows in the table.

Return Value

An IndexedDataTable<(Of <(TRow>)>) that contains the same rows as table and enables indexing of its rows.

Remarks

Use this method to index typed data tables and query them using the query operators optimized with indexing.

Elements of the source data table aren't duplicated or copied to a new collection. This method just wraps the original data table in an IndexedDataTable<(Of <(TRow>)>).

Note: The IndexedDataTable<(Of <(TRow>)>) wrapper is owned by the original DataTable object (in fact, it is stored in its ExtendedProperties). So, if you create a wrapper for the same data table several times, it will be the same object.

See Also

AdoNetExtensions Class
AsIndexed Overload
C1.LiveLinq.AdoNet Namespace


AsLive Method

[image] [image]

.NET Framework Class Library
AdoNetExtensions..::.AsLive Method
AdoNetExtensions Class See Also

Overload List

Name | Description
AsLive(DataTable) | Creates a view based on the specified ADO.NET DataTable.
AsLive<(Of <(TRow>)>)(DataTable) | Creates a view based on the specified ADO.NET DataTable.
AsLive<(Of <(TRow>)>)(TypedTableBase<(Of <(TRow>)>)) | Creates a view based on the specified typed data table.

See Also

AdoNetExtensions Class
AdoNetExtensions Members
C1.LiveLinq.AdoNet Namespace


AsLive Method (DataTable)

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsLive Method (DataTable)
AdoNetExtensions Class See Also
Creates a view based on the specified ADO.NET DataTable.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<DataRow> AsLive(
    DataTable table
)
Visual Basic (Declaration)
Public Shared Function AsLive ( _
    table As DataTable _
) As View(Of DataRow)

Parameters

table
Type: System.Data..::.DataTable
The DataTable to expose as a view.

Return Value

A view that contains the same elements as table.

See Also

AdoNetExtensions Class
AsLive Overload
C1.LiveLinq.AdoNet Namespace


AsLive(TRow) Method (DataTable)

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsLive<(Of <(TRow>)>) Method (DataTable)
AdoNetExtensions Class See Also
Creates a view based on the specified ADO.NET DataTable.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<TRow> AsLive<TRow>(
    DataTable table
)
where TRow : DataRow
Visual Basic (Declaration)
Public Shared Function AsLive(Of TRow As DataRow) ( _
    table As DataTable _
) As View(Of TRow)

Parameters

table
Type: System.Data..::.DataTable
The typed data table to expose as a view.

Type Parameters

TRow
The type of the rows in the table.

Return Value

A view that contains the same elements as table.

See Also

AdoNetExtensions Class
AsLive Overload
C1.LiveLinq.AdoNet Namespace


AsLive(TRow) Method (TypedTableBase(TRow))

[image]

.NET Framework Class Library
AdoNetExtensions..::.AsLive<(Of <(TRow>)>) Method (TypedTableBase<(Of <(TRow>)>))
AdoNetExtensions Class See Also
Creates a view based on the specified typed data table.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<TRow> AsLive<TRow>(
    TypedTableBase<TRow> table
)
where TRow : DataRow
Visual Basic (Declaration)
Public Shared Function AsLive(Of TRow As DataRow) ( _
    table As TypedTableBase(Of TRow) _
) As View(Of TRow)

Parameters

table
Type: System.Data..::.TypedTableBase <(Of <(TRow>)>)
The typed data table to expose as a view.

Type Parameters

TRow
The type of the rows in the table.

Return Value

A view that contains the same elements as table.

See Also

AdoNetExtensions Class
AsLive Overload
C1.LiveLinq.AdoNet Namespace


BeginUpdate Method

[image]

.NET Framework Class Library
AdoNetExtensions..::.BeginUpdate Method
AdoNetExtensions Class See Also
Indicates that massive changes are being made in code, until EndUpdate(DataSet), to data tables in this DataSet.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static void BeginUpdate(
    DataSet dataSet
)
Visual Basic (Declaration)
Public Shared Sub BeginUpdate ( _
    dataSet As DataSet _
)

Parameters

dataSet
Type: System.Data..::.DataSet
The DataSet to start massive changes for.

Remarks

This extension method calls BeginUpdate()()() for all data tables of this DataSet.

See Also

AdoNetExtensions Class
C1.LiveLinq.AdoNet Namespace


EndUpdate Method

[image]

.NET Framework Class Library
AdoNetExtensions..::.EndUpdate Method
AdoNetExtensions Class See Also
Indicates the end of massive changes to data tables in this DataSet started with BeginUpdate(DataSet).

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static void EndUpdate(
    DataSet dataSet
)
Visual Basic (Declaration)
Public Shared Sub EndUpdate ( _
    dataSet As DataSet _
)

Parameters

dataSet
Type: System.Data..::.DataSet
The DataSet where massive changes have ended.

Remarks

This extension method calls EndUpdate()()() for all data tables of this DataSet.

See Also

AdoNetExtensions Class
C1.LiveLinq.AdoNet Namespace


IndexedField Method

[image] [image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField Method
AdoNetExtensions Class See Also

Overload List

Name | Description
IndexedField<(Of <(T>)>)(DataRow, DataColumn) | A hint to create and use an index on the specified data column. The hint has default action.
IndexedField<(Of <(T>)>)(DataRow, Int32) | A hint to create and use an index on the specified data column. The hint has default action.
IndexedField<(Of <(T>)>)(DataRow, String) | A hint to create and use an index on the specified data column. The hint has default action.
IndexedField<(Of <(T>)>)(DataRow, DataColumn, IndexingHintAction) | A hint to create and use an index on the specified data column. The hint has specified action.
IndexedField<(Of <(T>)>)(DataRow, Int32, IndexingHintAction) | A hint to create and use an index on the specified data column. The hint has specified action.
IndexedField<(Of <(T>)>)(DataRow, String, IndexingHintAction) | A hint to create and use an index on the specified data column. The hint has specified action.

See Also

AdoNetExtensions Class
AdoNetExtensions Members
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, DataColumn)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, DataColumn)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has default action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    DataColumn column
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    column As DataColumn _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
column
Type: System.Data..::.DataColumn
The data column.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query = from c in customersTable
    where c.IndexedField<string>(customerColumn) == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, Int32)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, Int32)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has default action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    int columnIndex
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    columnIndex As Integer _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
columnIndex
Type: System..::.Int32
The zero-based ordinal position of the column.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query = from c in customersTable
    where c.IndexedField<string>(0) == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, String)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, String)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has default action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    string columnName
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    columnName As String _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
columnName
Type: System..::.String
The name of the column.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query = from c in customersTable
    where c.IndexedField<string>("CustomerID") == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, DataColumn, IndexingHintAction)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, DataColumn, IndexingHintAction)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has specified action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    DataColumn column,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    column As DataColumn, _
    action As IndexingHintAction _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
column
Type: System.Data..::.DataColumn
The data column.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customersTable
    where c.IndexedField<string>(customerColumn, IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, Int32, IndexingHintAction)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, Int32, IndexingHintAction)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has specified action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    int columnIndex,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    columnIndex As Integer, _
    action As IndexingHintAction _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
columnIndex
Type: System..::.Int32
The zero-based ordinal position of the column.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query = from c in customersTable
    where c.IndexedField<string>(0, IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedField(T) Method (DataRow, String, IndexingHintAction)

[image]

.NET Framework Class Library
AdoNetExtensions..::.IndexedField<(Of <(T>)>) Method (DataRow, String, IndexingHintAction)
AdoNetExtensions Class Example See Also
A hint to create and use an index on the specified data column. The hint has specified action.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static T IndexedField<T>(
    DataRow row,
    string columnName,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedField(Of T) ( _
    row As DataRow, _
    columnName As String, _
    action As IndexingHintAction _
) As T

Parameters

row
Type: System.Data..::.DataRow
The data row.
columnName
Type: System..::.String
The name of the column.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Type Parameters

T
The type of the data column

Return Value

The data column value.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on that column, if possible. When the query is executed, the hint method IndexedField is replaced with the standard LINQ to DataSet extension method Field. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customersTable
    where c.IndexedField<string>("CustomerID", IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

AdoNetExtensions Class
IndexedField Overload
C1.LiveLinq.AdoNet Namespace


IndexedDataTable(TRow) Class

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>) Class
Members See Also
A wrapper for the standard ADO.NET DataTable class allowing to use ADO.NET data sources in LiveLinq indexing and live views.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class IndexedDataTable<TRow> : IObservableSource<T>,
    IIndexedSource<T>, IList<T>, ICollection<T>, IEnumerable<T>,
    IEnumerable, ITypedList, IListSource
where TRow : DataRow
Visual Basic (Declaration)
Public Class IndexedDataTable(Of TRow As DataRow) _
    Implements IObservableSource(Of T), IIndexedSource(Of T),  _
    IList(Of T), ICollection(Of T), IEnumerable(Of T),  _
    IEnumerable, ITypedList, IListSource

Type Parameters

TRow
The type of the rows of the DataTable. It is a class derived from DataRow

Remarks

Note: The IndexedDataTable wrapper is owned by the original DataTable object (in fact, it is stored in its ExtendedProperties). So, if you create a wrapper for the same data table several times, it will be the same object.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.AdoNet..::.IndexedDataTable<(Of <(TRow>)>)

See Also

IndexedDataTable<(Of <(TRow>)>) Members
C1.LiveLinq.AdoNet Namespace


IndexedDataTable(TRow) Members

[image] [image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>) Members
IndexedDataTable<(Of <(TRow>)>) Class Methods Properties See Also

The IndexedDataTable<(Of <(TRow>)>) type exposes the following members.

Methods

Name | Description
BeginUpdate | Suspends notifications while massive changes are being made to a data table.
EndUpdate | Ends notification suspension started with BeginUpdate()()().
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexedDataTable<(Of <(TRow>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the number of rows in the data table.
Indexes | The collection of indexes for this IndexedDataTable<(Of <(TRow>)>)
Item | Gets the row at the specified ordinal position.
Table | Gets the ADO.NET DataTable object represented by this IndexedDataTable<(Of <(TRow>)>).

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IndexedDataTable(TRow) Methods

[image] [image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>) Methods
IndexedDataTable<(Of <(TRow>)>) Class See Also

The IndexedDataTable<(Of <(TRow>)>) type exposes the following members.

Methods

Name | Description
BeginUpdate | Suspends notifications while massive changes are being made to a data table.
EndUpdate | Ends notification suspension started with BeginUpdate()()().
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the IndexedDataTable<(Of <(TRow>)>).
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


BeginUpdate Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.BeginUpdate Method
IndexedDataTable<(Of <(TRow>)>) Class See Also
Suspends notifications while massive changes are being made to a data table.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void BeginUpdate()
Visual Basic (Declaration)
Public Sub BeginUpdate

Remarks

This method must be followed by EndUpdate()()().

Use this method when you already have indexes built over a data table or live views based on that data table, and you need to re-populate it or perform other massive changes to rows of that data table. Without this method, every single change you make causes LiveLinq to perform necessary operations for maintaining your indexes and live views dependent on this data table. In case of massive changes, this can be slower than to wait until the massive changes are done and rebuild the indexes and live views.

Between BeginUpdate and EndUpdate()()() calls, indexes, live views, bound controls and other change notification listeners are not updated, they don't receive change notifications.

When EndUpdate()()() is called, a SourceChangeType.Modify or SourceChangeType.Reset notification is sent, depending on whether the change affected a single row or multiple rows of the data table. Even when you change a single row, it may make sense to enclose your changes in BeginUpdate/EndUpdate if you change multiple fields in the row. In that case a SourceChangeType.Modify notification is sent. If more than one row was changed, a SourceChangeType.Reset notification is sent, meaning all indexes, live views and other collections dependent on this data table must be rebuilt from scratch.

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


EndUpdate Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.EndUpdate Method
IndexedDataTable<(Of <(TRow>)>) Class See Also
Ends notification suspension started with BeginUpdate()()().

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void EndUpdate()
Visual Basic (Declaration)
Public Sub EndUpdate

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.GetEnumerator Method
IndexedDataTable<(Of <(TRow>)>) Class See Also
Returns an enumerator that iterates through the IndexedDataTable<(Of <(TRow>)>).

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerator<TRow> GetEnumerator()
Visual Basic (Declaration)
Public Function GetEnumerator As IEnumerator(Of TRow)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IndexedDataTable(TRow) Properties

[image] [image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>) Properties
IndexedDataTable<(Of <(TRow>)>) Class See Also

The IndexedDataTable<(Of <(TRow>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the number of rows in the data table.
Indexes | The collection of indexes for this IndexedDataTable<(Of <(TRow>)>)
Item | Gets the row at the specified ordinal position.
Table | Gets the ADO.NET DataTable object represented by this IndexedDataTable<(Of <(TRow>)>).

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


Count Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.Count Property
IndexedDataTable<(Of <(TRow>)>) Class See Also
Gets the number of rows in the data table.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int Count { get; }
Visual Basic (Declaration)
Public ReadOnly Property Count As Integer

Implements

ICollection<(Of <(T>)>)..::.Count

Remarks

This property returns the same number of rows as the Count property of the DataTable represented by this IndexedDataTable<(Of <(TRow>)>)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


Indexes Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.Indexes Property
IndexedDataTable<(Of <(TRow>)>) Class See Also
The collection of indexes for this IndexedDataTable<(Of <(TRow>)>)

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexCollection<TRow> Indexes { get; private set; }
Visual Basic (Declaration)
Public Property Indexes As IndexCollection(Of TRow)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


Item Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.Item Property
IndexedDataTable<(Of <(TRow>)>) Class See Also
Gets the row at the specified ordinal position.

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public TRow this[
    int ordinal
] { get; }
Visual Basic (Declaration)
Public ReadOnly Default Property Item ( _
    ordinal As Integer _
) As TRow

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal position of the row to return.

Return Value

The specified row.

Remarks

This property returns the same row as Rows[ordinal] of the DataTable represented by this IndexedDataTable<(Of <(TRow>)>).

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


Table Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.Table Property
IndexedDataTable<(Of <(TRow>)>) Class See Also
Gets the ADO.NET DataTable object represented by this IndexedDataTable<(Of <(TRow>)>).

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public DataTable Table { get; private set; }
Visual Basic (Declaration)
Public Property Table As DataTable

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


C1.LiveLinq.LiveViews Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.LiveViews Namespace

Classes

Class | Description
AggregationView<(Of <(TSource, TResult>)>) | Represents a view having a single element calculated by aggregating a source view.
GroupView<(Of <(TKey, TElement>)>) | A group in a grouping view.
OrderedView<(Of <(T>)>) | Represents a sorted view.
View | Base class for the View<(Of <(T>)>) class. Contains members that don't depend on the element type T.
View<(Of <(T>)>) | Represents a live view: a LINQ query result that supports two-way data binding and is kept up-to-date with base data.
ViewRow | Represents a view element (item) for the purposes of dynamic, programmatic access to its properties and data binding.
ViewRowAddingEventArgs | Provides data for the ViewRowAdding event.
ViewRowCollection | Represents a collection of ViewRow objects used for programmatic access to view elements (items) and for data binding.

Enumerations

Enumeration | Description
ViewMaintenanceMode | Specifies how a view is synchronized with changes in its base data.
ViewOrder | Specifies whether and how a view must preserve item order if it exists in the source.
ViewRowState | The state of a view row with regard to edit, add and delete operations if they are performed directly on the view.


AggregationView(TSource, TResult) Class

[image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>) Class
Members See Also
Represents a view having a single element calculated by aggregating a source view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class AggregationView<TSource, TResult> : View<TElement>
Visual Basic (Declaration)
Public Class AggregationView(Of TSource, TResult) _
    Inherits View(Of TElement)

Type Parameters

TSource
The type of the elements of the source view.
TResult
The type of the single element of the aggregation view.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.View
C1.LiveLinq.LiveViews..::.View <(Of <( TElement >)>)
C1.LiveLinq.LiveViews..::.AggregationView<(Of <(TSource, TResult>)>)

See Also

AggregationView<(Of <(TSource, TResult>)>) Members
C1.LiveLinq.LiveViews Namespace


AggregationView(TSource, TResult) Members

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>) Members
AggregationView<(Of <(TSource, TResult>)>) Class Methods Properties Events See Also

The AggregationView<(Of <(TSource, TResult>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ToString | Returns a string representing this view. (Inherited from View<(Of <(T>)>).)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)
Value | Gets the value of the single element of the aggregation view.

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
C1.LiveLinq.LiveViews Namespace


AggregationView(TSource, TResult) Methods

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>) Methods
AggregationView<(Of <(TSource, TResult>)>) Class See Also

The AggregationView<(Of <(TSource, TResult>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ToString | Returns a string representing this view. (Inherited from View<(Of <(T>)>).)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
C1.LiveLinq.LiveViews Namespace


AttachAggregationView Method

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>)..::.AttachAggregationView Method
AggregationView<(Of <(TSource, TResult>)>) Class See Also

Overload List

Name | Description
AttachAggregationView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
AggregationView<(Of <(TSource, TResult>)>) Members
C1.LiveLinq.LiveViews Namespace


AttachView Method

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>)..::.AttachView Method
AggregationView<(Of <(TSource, TResult>)>) Class See Also

Overload List

Name | Description
AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
AggregationView<(Of <(TSource, TResult>)>) Members
C1.LiveLinq.LiveViews Namespace


GroupBy Method

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>)..::.GroupBy Method
AggregationView<(Of <(TSource, TResult>)>) Class See Also

Overload List

Name | Description
GroupBy<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Groups the elements of a view according to a specified key selector function. (Inherited from View<(Of <(T>)>).)
GroupBy<(Of <(TKey, TElement>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, TElement>)>)>)>)) | Groups the elements of a view according to a specified key selector function and projects the elements for each group by using a specified function. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
AggregationView<(Of <(TSource, TResult>)>) Members
C1.LiveLinq.LiveViews Namespace


SelectMany Method

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>)..::.SelectMany Method
AggregationView<(Of <(TSource, TResult>)>) Class See Also

Overload List

Name | Description
SelectMany<(Of <(TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TResult>)>)>)>)>)>)) | Projects each element of this view to a collection of TResult and flattens the resulting collections into one view. (Inherited from View<(Of <(T>)>).)
SelectMany<(Of <(TCollection, TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(T, TCollection, TResult>)>)>)>)) | Projects each element of this view to a collection of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
AggregationView<(Of <(TSource, TResult>)>) Members
C1.LiveLinq.LiveViews Namespace


AggregationView(TSource, TResult) Properties

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>) Properties
AggregationView<(Of <(TSource, TResult>)>) Class See Also

The AggregationView<(Of <(TSource, TResult>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)
Value | Gets the value of the single element of the aggregation view.

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
C1.LiveLinq.LiveViews Namespace


Value Property

[image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>)..::.Value Property
AggregationView<(Of <(TSource, TResult>)>) Class See Also
Gets the value of the single element of the aggregation view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public TResult Value { get; }
Visual Basic (Declaration)
Public ReadOnly Property Value As TResult

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
C1.LiveLinq.LiveViews Namespace


AggregationView(TSource, TResult) Events

[image] [image]

.NET Framework Class Library
AggregationView<(Of <(TSource, TResult>)>) Events
AggregationView<(Of <(TSource, TResult>)>) Class See Also

The AggregationView<(Of <(TSource, TResult>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

AggregationView<(Of <(TSource, TResult>)>) Class
C1.LiveLinq.LiveViews Namespace


GroupView(TKey, TElement) Class

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>) Class
Members See Also
A group in a grouping view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public sealed class GroupView<TKey, TElement> : View<TElement>,
    IGrouping<TKey, T>, IEnumerable<TKey>, IEnumerable
Visual Basic (Declaration)
Public NotInheritable Class GroupView(Of TKey, TElement) _
    Inherits View(Of TElement) _
    Implements IGrouping(Of TKey, T), IEnumerable(Of TKey),  _
    IEnumerable

Type Parameters

TKey
The type of the key used for grouping.
TElement
The type of the elements in the group view.

Remarks

A grouping view is a result of a GroupBy operation on a live view. It is a collection of groups. Each group contains elements with the same key. That collection is a live view, and every group in itself is a live view, an object of type GroupView<TKey, TElement>.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.View
C1.LiveLinq.LiveViews..::.View <(Of <(TElement>)>)
C1.LiveLinq.LiveViews..::.GroupView<(Of <(TKey, TElement>)>)

See Also

GroupView<(Of <(TKey, TElement>)>) Members
C1.LiveLinq.LiveViews Namespace


GroupView(TKey, TElement) Members

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>) Members
GroupView<(Of <(TKey, TElement>)>) Class Methods Properties Events See Also

The GroupView<(Of <(TKey, TElement>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | This method overrides Maintain()()(). (Overrides View..::.Maintain()()().)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | This method overrides PurgeEmptyGroups()()(). (Overrides View..::.PurgeEmptyGroups()()().)
Rebuild | This method overrides Rebuild()()(). (Overrides View..::.Rebuild()()().)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ToString | Returns a string that represents this instance of GroupView<(Of <(TKey, TElement>)>) (Overrides View<(Of <(T>)>)..::.ToString()()().)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | This property overrides DeferredMaintenance. (Overrides View..::.DeferredMaintenance.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
Key | Gets the key value of the group.
MaintenanceMode | This property overrides MaintenanceMode. (Overrides View..::.MaintenanceMode.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Parent | Gets the grouping view (the result of a GroupBy operation) to which this group belongs.
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


GroupView(TKey, TElement) Methods

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>) Methods
GroupView<(Of <(TKey, TElement>)>) Class See Also

The GroupView<(Of <(TKey, TElement>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | This method overrides Maintain()()(). (Overrides View..::.Maintain()()().)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | This method overrides PurgeEmptyGroups()()(). (Overrides View..::.PurgeEmptyGroups()()().)
Rebuild | This method overrides Rebuild()()(). (Overrides View..::.Rebuild()()().)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ToString | Returns a string that represents this instance of GroupView<(Of <(TKey, TElement>)>) (Overrides View<(Of <(T>)>)..::.ToString()()().)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


AttachAggregationView Method

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.AttachAggregationView Method
GroupView<(Of <(TKey, TElement>)>) Class See Also

Overload List

Name | Description
AttachAggregationView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
GroupView<(Of <(TKey, TElement>)>) Members
C1.LiveLinq.LiveViews Namespace


AttachView Method

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.AttachView Method
GroupView<(Of <(TKey, TElement>)>) Class See Also

Overload List

Name | Description
AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
GroupView<(Of <(TKey, TElement>)>) Members
C1.LiveLinq.LiveViews Namespace


GroupBy Method

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.GroupBy Method
GroupView<(Of <(TKey, TElement>)>) Class See Also

Overload List

Name | Description
GroupBy<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Groups the elements of a view according to a specified key selector function. (Inherited from View<(Of <(T>)>).)
GroupBy<(Of <(TKey, TElement>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, TElement>)>)>)>)) | Groups the elements of a view according to a specified key selector function and projects the elements for each group by using a specified function. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
GroupView<(Of <(TKey, TElement>)>) Members
C1.LiveLinq.LiveViews Namespace


Maintain Method

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.Maintain Method
GroupView<(Of <(TKey, TElement>)>) Class See Also
This method overrides Maintain()()().

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override void Maintain()
Visual Basic (Declaration)
Public Overrides Sub Maintain

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


PurgeEmptyGroups Method

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.PurgeEmptyGroups Method
GroupView<(Of <(TKey, TElement>)>) Class See Also
This method overrides PurgeEmptyGroups()()().

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override void PurgeEmptyGroups()
Visual Basic (Declaration)
Public Overrides Sub PurgeEmptyGroups

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


Rebuild Method

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.Rebuild Method
GroupView<(Of <(TKey, TElement>)>) Class See Also
This method overrides Rebuild()()().

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override void Rebuild()
Visual Basic (Declaration)
Public Overrides Sub Rebuild

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


SelectMany Method

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.SelectMany Method
GroupView<(Of <(TKey, TElement>)>) Class See Also

Overload List

Name | Description
SelectMany<(Of <(TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TResult>)>)>)>)>)>)) | Projects each element of this view to a collection of TResult and flattens the resulting collections into one view. (Inherited from View<(Of <(T>)>).)
SelectMany<(Of <(TCollection, TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(T, TCollection, TResult>)>)>)>)) | Projects each element of this view to a collection of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
GroupView<(Of <(TKey, TElement>)>) Members
C1.LiveLinq.LiveViews Namespace


ToString Method

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.ToString Method
GroupView<(Of <(TKey, TElement>)>) Class See Also
Returns a string that represents this instance of GroupView<(Of <(TKey, TElement>)>)

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override string ToString()
Visual Basic (Declaration)
Public Overrides Function ToString As String

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


GroupView(TKey, TElement) Properties

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>) Properties
GroupView<(Of <(TKey, TElement>)>) Class See Also

The GroupView<(Of <(TKey, TElement>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | This property overrides DeferredMaintenance. (Overrides View..::.DeferredMaintenance.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
Key | Gets the key value of the group.
MaintenanceMode | This property overrides MaintenanceMode. (Overrides View..::.MaintenanceMode.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Parent | Gets the grouping view (the result of a GroupBy operation) to which this group belongs.
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


DeferredMaintenance Property

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.DeferredMaintenance Property
GroupView<(Of <(TKey, TElement>)>) Class See Also
This property overrides DeferredMaintenance.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override bool DeferredMaintenance { get; }
Visual Basic (Declaration)
Public Overrides ReadOnly Property DeferredMaintenance As Boolean

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


Key Property

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.Key Property
GroupView<(Of <(TKey, TElement>)>) Class See Also
Gets the key value of the group.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public TKey Key { get; }
Visual Basic (Declaration)
Public ReadOnly Property Key As TKey

Remarks

The key value is common to the elements of this group.

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


MaintenanceMode Property

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.MaintenanceMode Property
GroupView<(Of <(TKey, TElement>)>) Class See Also
This property overrides MaintenanceMode.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override ViewMaintenanceMode MaintenanceMode { get; set; }
Visual Basic (Declaration)
Public Overrides Property MaintenanceMode As ViewMaintenanceMode

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


Parent Property

[image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>)..::.Parent Property
GroupView<(Of <(TKey, TElement>)>) Class See Also
Gets the grouping view (the result of a GroupBy operation) to which this group belongs.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View Parent { get; }
Visual Basic (Declaration)
Public ReadOnly Property Parent As View

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


GroupView(TKey, TElement) Events

[image] [image]

.NET Framework Class Library
GroupView<(Of <(TKey, TElement>)>) Events
GroupView<(Of <(TKey, TElement>)>) Class See Also

The GroupView<(Of <(TKey, TElement>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

GroupView<(Of <(TKey, TElement>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderedView(T) Class

[image]

.NET Framework Class Library
OrderedView<(Of <(T>)>) Class
Members See Also
Represents a sorted view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class OrderedView<T> : View<T>
Visual Basic (Declaration)
Public Class OrderedView(Of T) _
    Inherits View(Of T)

Type Parameters

T
The type of the elements in the view.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.View
C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
C1.LiveLinq.LiveViews..::.OrderedView<(Of <(T>)>)

See Also

OrderedView<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.OrderBy<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
View<(Of <(T>)>)..::.OrderByDescending<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))


OrderedView(T) Members

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>) Members
OrderedView<(Of <(T>)>) Class Methods Properties Events See Also

The OrderedView<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ThenBy<(Of <(TKey>)>) | Performs a subsequent ordering of view elements in ascending order according to a key.
ThenByDescending<(Of <(TKey>)>) | Performs a subsequent ordering of view elements in descending order according to a key.
ToString | Returns a string representing this view. (Inherited from View<(Of <(T>)>).)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderedView(T) Methods

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>) Methods
OrderedView<(Of <(T>)>) Class See Also

The OrderedView<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views. (Inherited from View<(Of <(T>)>).)
Contains | Determines whether the view contains a specified item. (Inherited from View<(Of <(T>)>).)
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items. (Inherited from View<(Of <(T>)>).)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results. (Inherited from View<(Of <(T>)>).)
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence. (Inherited from View<(Of <(T>)>).)
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys. (Inherited from View<(Of <(T>)>).)
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order. (Inherited from View<(Of <(T>)>).)
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order. (Inherited from View<(Of <(T>)>).)
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form. (Inherited from View<(Of <(T>)>).)
SelectMany | Overloaded.
ThenBy<(Of <(TKey>)>) | Performs a subsequent ordering of view elements in ascending order according to a key.
ThenByDescending<(Of <(TKey>)>) | Performs a subsequent ordering of view elements in descending order according to a key.
ToString | Returns a string representing this view. (Inherited from View<(Of <(T>)>).)
Union | Set union of two views. (Inherited from View<(Of <(T>)>).)
Where | Filters the source view based on a predicate. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


AttachAggregationView Method

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.AttachAggregationView Method
OrderedView<(Of <(T>)>) Class See Also

Overload List

Name | Description
AttachAggregationView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
OrderedView<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


AttachView Method

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.AttachView Method
OrderedView<(Of <(T>)>) Class See Also

Overload List

Name | Description
AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view. (Inherited from View<(Of <(T>)>).)
AttachView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
OrderedView<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


GroupBy Method

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.GroupBy Method
OrderedView<(Of <(T>)>) Class See Also

Overload List

Name | Description
GroupBy<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Groups the elements of a view according to a specified key selector function. (Inherited from View<(Of <(T>)>).)
GroupBy<(Of <(TKey, TElement>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, TElement>)>)>)>)) | Groups the elements of a view according to a specified key selector function and projects the elements for each group by using a specified function. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
OrderedView<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


SelectMany Method

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.SelectMany Method
OrderedView<(Of <(T>)>) Class See Also

Overload List

Name | Description
SelectMany<(Of <(TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TResult>)>)>)>)>)>)) | Projects each element of this view to a collection of TResult and flattens the resulting collections into one view. (Inherited from View<(Of <(T>)>).)
SelectMany<(Of <(TCollection, TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(T, TCollection, TResult>)>)>)>)) | Projects each element of this view to a collection of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
OrderedView<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


ThenBy(TKey) Method

[image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.ThenBy<(Of <(TKey>)>) Method
OrderedView<(Of <(T>)>) Class See Also
Performs a subsequent ordering of view elements in ascending order according to a key.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public OrderedView<T> ThenBy<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function ThenBy(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As OrderedView(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from each element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A view whose elements are sorted according to a key.

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ThenByDescending(TKey) Method

[image]

.NET Framework Class Library
OrderedView<(Of <(T>)>)..::.ThenByDescending<(Of <(TKey>)>) Method
OrderedView<(Of <(T>)>) Class See Also
Performs a subsequent ordering of view elements in descending order according to a key.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public OrderedView<T> ThenByDescending<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function ThenByDescending(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As OrderedView(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from each element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A view whose elements are sorted in descending order according to a key.

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderedView(T) Properties

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>) Properties
OrderedView<(Of <(T>)>) Class See Also

The OrderedView<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view. (Inherited from View<(Of <(T>)>).)
IsReadOnly | This property overrides IsReadOnly. (Inherited from View<(Of <(T>)>).)
Item | Gets the view item (element) at the specified ordinal position. (Inherited from View<(Of <(T>)>).)
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderedView(T) Events

[image] [image]

.NET Framework Class Library
OrderedView<(Of <(T>)>) Events
OrderedView<(Of <(T>)>) Class See Also

The OrderedView<(Of <(T>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed. (Inherited from View<(Of <(T>)>).)
Changing | Occurs before an item of the view or the entire view changes. (Inherited from View<(Of <(T>)>).)

See Also

OrderedView<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


View Class

[image]

.NET Framework Class Library
View Class
Members See Also
Base class for the View<(Of <(T>)>) class. Contains members that don't depend on the element type T.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class View : IList,
    ICollection, IEnumerable, IListSource
Visual Basic (Declaration)
Public MustInherit Class View _
    Implements IList, ICollection, IEnumerable, IListSource

Remarks

Use this class to type variables that can accept views with different element types or a view with anonymous element type.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.View
C1.LiveLinq.LiveViews..::.View<(Of <(T>)>)

See Also

View Members
C1.LiveLinq.LiveViews Namespace


View Members

[image] [image]

.NET Framework Class Library
View Members
View Class Methods Properties See Also

The View type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
Maintain | Brings the view up to date with its source data.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
PurgeEmptyGroups | Remove empty groups from a grouping view.
Rebuild | Re-populates the view by re-executing the view's query.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Count | Gets the total number of elements in the view.
DeferredMaintenance | Gets the effective value of MaintenanceMode.
IsReadOnly | Gets a value indicating whether this view is read-only, not updatable.
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data.
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source.
Rows | Gets the collection of ViewRow objects used for programmatic access to view elements (items) and for data binding.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


View Methods

[image] [image]

.NET Framework Class Library
View Methods
View Class See Also

The View type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
Maintain | Brings the view up to date with its source data.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
PurgeEmptyGroups | Remove empty groups from a grouping view.
Rebuild | Re-populates the view by re-executing the view's query.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


Maintain Method

[image]

.NET Framework Class Library
View..::.Maintain Method
View Class See Also
Brings the view up to date with its source data.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void Maintain()
Visual Basic (Declaration)
Public Overridable Sub Maintain

Remarks

If source data have not changed since the last time the view was maintained (updated), this method does nothing. It also does nothing if the view's MaintenanceMode is Immediate, because in that case the view is guaranteed to be in synch with its base data at all times. If the view is in deferred mode (its MaintenanceMode property returns true), the programmer can use the Maintain method to force updating the view.

Note that it is not necessary to call Maintain to make sure you get updated data from the view. The view is automatically updated every time you request data from it, if base data changed since the last request, regardless of the view's MaintenanceMode.

LiveLinq maintains views using optimized incremental algorithms, not simply re-populates them from scratch. It calculating the delta in the view from the delta in the base data. In most cases, it allows to propagate the change from base data to the view very fast.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


PurgeEmptyGroups Method

[image]

.NET Framework Class Library
View..::.PurgeEmptyGroups Method
View Class See Also
Remove empty groups from a grouping view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void PurgeEmptyGroups()
Visual Basic (Declaration)
Public Overridable Sub PurgeEmptyGroups

Remarks

This method is used only for GroupBy (grouping) views, does nothing for views of other kinds.

When a grouping view is populated, it does not contain empty groups. But later, as a result of maintaining the grouping view, keeping it in synch with changes in its base data, some of the groups can become empty. If it is undesirable to have empty groups, you can call this method to delete them.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


Rebuild Method

[image]

.NET Framework Class Library
View..::.Rebuild Method
View Class See Also
Re-populates the view by re-executing the view's query.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void Rebuild()
Visual Basic (Declaration)
Public Overridable Sub Rebuild

Remarks

This method is rarely needed, because normally automatic incremental maintenance is faster than re-executing the query over the entire base data collection. However, if for some reason you need to re-populate it from scratch, that can be done with the Rebuild method.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


View Properties

[image] [image]

.NET Framework Class Library
View Properties
View Class See Also

The View type exposes the following members.

Properties

Name | Description
Count | Gets the total number of elements in the view.
DeferredMaintenance | Gets the effective value of MaintenanceMode.
IsReadOnly | Gets a value indicating whether this view is read-only, not updatable.
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data.
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source.
Rows | Gets the collection of ViewRow objects used for programmatic access to view elements (items) and for data binding.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


Count Property

[image]

.NET Framework Class Library
View..::.Count Property
View Class See Also
Gets the total number of elements in the view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int Count { get; }
Visual Basic (Declaration)
Public ReadOnly Property Count As Integer

Implements

ICollection..::.Count

See Also

View Class
C1.LiveLinq.LiveViews Namespace


DeferredMaintenance Property

[image]

.NET Framework Class Library
View..::.DeferredMaintenance Property
View Class See Also
Gets the effective value of MaintenanceMode.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual bool DeferredMaintenance { get; }
Visual Basic (Declaration)
Public Overridable ReadOnly Property DeferredMaintenance As Boolean

Return Value

true if MaintenanceMode is set to Deferred, or if it is set to Default and no listeners are registered with this view.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IsReadOnly Property

[image]

.NET Framework Class Library
View..::.IsReadOnly Property
View Class See Also
Gets a value indicating whether this view is read-only, not updatable.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract bool IsReadOnly { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property IsReadOnly As Boolean

Implements

IList..::.IsReadOnly

Remarks

Properties exposed by a view can be updatable or read-only. Updatable properties of a view can be modified directly in the view.

All properties of a read-only (not updatable) view are read-only. In an updatable view, properties directly corresponding to base data (source) properties are updatable, calculated properties are read-only. For example, in a view

Copy CodeC#
from x in X
select new { x.P, Q = x.Q + 1 }
P is updatable and Q is read-only.

Read-only properties of a view cannot be modified directly in the view, but they still reflect up-to-date values of the source, so the difference is often not critical, you can always modify corresponding property in the source, that will automatically change the property in the view.

Also, a read-only view cannot be cleared or its rows deleted or new rows added directly in the view (but all these actions can be performed on the source data collection and they will normally result in the corresponding changes of the view).

A Join view is read-only by default, but one of its two parts can be made updatable using the AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>)) method.

See Also

View Class
C1.LiveLinq.LiveViews Namespace
LiveViewExtensions..::.AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))
C1.LiveLinq.LiveViews..::.ViewRow
C1.LiveLinq.LiveViews..::.ViewRowState


MaintenanceMode Property

[image]

.NET Framework Class Library
View..::.MaintenanceMode Property
View Class See Also
Gets or sets a value controlling how the view is synchronized with changes in its base data.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual ViewMaintenanceMode MaintenanceMode { get; set; }
Visual Basic (Declaration)
Public Overridable Property MaintenanceMode As ViewMaintenanceMode

Remarks

A view in Default mode (which is the default value for this property) is effectively in Immediate mode if it has a listener (for example, if a GUI control is bound to it); otherwise it is in Deferred mode. To find out whether the view is effectively in Deferred or in Immediate mode, you can use the DeferredMaintenance property.

If you set this property to Deferred, no listeners are allowed to register with this view. An attempt to register a listener will result in an exception.

See Also: View Maintenance Mode.

See Also

View Class
C1.LiveLinq.LiveViews Namespace
View..::.DeferredMaintenance


Order Property

[image]

.NET Framework Class Library
View..::.Order Property
View Class See Also
Gets a value indicating whether and how this view preserves item order if it exists in its base data source.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ViewOrder Order { get; }
Visual Basic (Declaration)
Public ReadOnly Property Order As ViewOrder

See Also

View Class
C1.LiveLinq.LiveViews Namespace


Rows Property

[image]

.NET Framework Class Library
View..::.Rows Property
View Class See Also
Gets the collection of ViewRow objects used for programmatic access to view elements (items) and for data binding.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract ViewRowCollection Rows { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property Rows As ViewRowCollection

Remarks

There can be a view with elements of any type T, as represented by the generic class View<(Of <(T>)>). That type is not always known beforehand, so it is not always possible to access properties of view elements with strong-typed (early binding) code. Dynamic (untyped, late binding) access to view elements is provided by the ViewRowCollection owned by the view.

The collection of view rows (ViewRow objects) is always synchronized with the collection of view elements. ViewRow objects provide programmatic access to view elements and their properties.

Also, the Rows collection serves as the data source for data binding, when you bind a control or another client to a view, because a view returns its Rows collection in its implementation of the IListSource interface.

See Also

View Class
C1.LiveLinq.LiveViews Namespace


View(T) Class

[image]

.NET Framework Class Library
View<(Of <(T>)>) Class
Members See Also
Represents a live view: a LINQ query result that supports two-way data binding and is kept up-to-date with base data.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class View<T> : View, IList<T>,
    ICollection<T>, IObservableSource<T>, IIndexedSource<T>, IEnumerable<T>,
    IEnumerable, IDisposable
Visual Basic (Declaration)
Public Class View(Of T) _
    Inherits View _
    Implements IList(Of T), ICollection(Of T),  _
    IObservableSource(Of T), IIndexedSource(Of T), IEnumerable(Of T),  _
    IEnumerable, IDisposable

Type Parameters

T
The type of the elements in the view.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.View
C1.LiveLinq.LiveViews..::.View<(Of <(T>)>)
C1.LiveLinq.LiveViews..::.AggregationView<(Of <(TSource, TResult>)>)
C1.LiveLinq.LiveViews..::.GroupView<(Of <(TKey, TElement>)>)
C1.LiveLinq.LiveViews..::.OrderedView<(Of <(T>)>)

See Also

View<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


View(T) Members

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>) Members
View<(Of <(T>)>) Class Methods Properties Events See Also

The View<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views.
Contains | Determines whether the view contains a specified item.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items.
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results.
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence.
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys.
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order.
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order.
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form.
SelectMany | Overloaded.
ToString | Returns a string representing this view. (Overrides Object..::.ToString()()().)
Union | Set union of two views.
Where | Filters the source view based on a predicate.

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view.
IsReadOnly | This property overrides IsReadOnly. (Overrides View..::.IsReadOnly.)
Item | Gets the view item (element) at the specified ordinal position.
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Overrides View..::.Rows.)

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed.
Changing | Occurs before an item of the view or the entire view changes.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


View(T) Methods

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>) Methods
View<(Of <(T>)>) Class See Also

The View<(Of <(T>)>) type exposes the following members.

Methods

Name | Description
AttachAggregationView | Overloaded.
AttachView | Overloaded.
Concat | Concatenation of two views.
Contains | Determines whether the view contains a specified item.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through the view items.
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
GroupBy | Overloaded.
GroupJoin<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on equality of keys and groups the results.
IndexOf | Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence.
Join<(Of <(TInner, TKey, TResult>)>) | Correlates the elements of two views based on matching keys.
Maintain | Brings the view up to date with its source data. (Inherited from View.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OrderBy<(Of <(TKey>)>) | Sorts the elements of a view in ascending order.
OrderByDescending<(Of <(TKey>)>) | Sorts the elements of a view in descending order.
PurgeEmptyGroups | Remove empty groups from a grouping view. (Inherited from View.)
Rebuild | Re-populates the view by re-executing the view's query. (Inherited from View.)
Select<(Of <(TResult>)>) | Projects each element of a view into a new form.
SelectMany | Overloaded.
ToString | Returns a string representing this view. (Overrides Object..::.ToString()()().)
Union | Set union of two views.
Where | Filters the source view based on a predicate.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


AttachAggregationView Method

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachAggregationView Method
View<(Of <(T>)>) Class See Also

Overload List

Name | Description
AttachAggregationView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view.
AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>)) | Includes an aggregation subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view.

See Also

View<(Of <(T>)>) Class
View<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


AttachAggregationView(TResult) Method (Func(View(T), AggregationView(T, TResult)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachAggregationView<(Of <(TResult>)>) Method (Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>))
View<(Of <(T>)>) Class See Also
Includes an aggregation subquery into the incremental maintenance mechanism of a view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public AggregationView<T, TResult> AttachAggregationView<TResult>(
    Func<View<T>, AggregationView<T, TResult>> selector
)
Visual Basic (Declaration)
Public Function AttachAggregationView(Of TResult) ( _
    selector As Func(Of View(Of T), AggregationView(Of T, TResult)) _
) As AggregationView(Of T, TResult)

Parameters

selector
Type: System..::.Func <(Of <( View <(Of <( T >)>), AggregationView <(Of <( T, TResult>)>)>)>)
A function to obtain the attached aggregation subview from the view to which it is attached.

Type Parameters

TResult
The type of the elements in the aggregation subview.

Return Value

The attached aggregation subview.

Remarks

Subquery is a query inside a function that is a part of an outer query. If the outer query is a live view, and its base data changes so it needs to recompute the function, by default it just evaluates the function, which means creating a new view object for the subquery on every such recomputation. To improve performance by avoiding repeated creation of subviews, use the AttachAggregationView method to make the outer view aware of its subview. Then the outer view will cache and reuse subview objects it creates.

If there are more than one subviews attached to a single view, every subview must be supplied with a unique subview id by using the AttachAggregationView overload with subviewId parameter.

Examples

Copy CodeC#
var productView =
    from p in products
    join s in sales on p.ProductID equals s.ProductID into productSales
    select new
    {
        p.Name,
        ProductTotal = productSales.AttachAggregationView(v => v.LiveSum(s => s.Quantity))
    };

See Also

View<(Of <(T>)>) Class
AttachAggregationView Overload
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>))


AttachAggregationView(TResult) Method (Object, Func(View(T), AggregationView(T, TResult)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachAggregationView<(Of <(TResult>)>) Method (Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>))
View<(Of <(T>)>) Class See Also
Includes an aggregation subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public AggregationView<T, TResult> AttachAggregationView<TResult>(
    Object subqueryId,
    Func<View<T>, AggregationView<T, TResult>> selector
)
Visual Basic (Declaration)
Public Function AttachAggregationView(Of TResult) ( _
    subqueryId As Object, _
    selector As Func(Of View(Of T), AggregationView(Of T, TResult)) _
) As AggregationView(Of T, TResult)

Parameters

subqueryId
Type: System..::.Object
A string uniquely specifying this subquery in the view to which it is attached. Can be any string. The only requirement is that different subqueries attached to the same view, if such exist, must have different subquery ids.
selector
Type: System..::.Func <(Of <( View <(Of <( T >)>), AggregationView <(Of <( T, TResult>)>)>)>)
A function to obtain the attached aggregation subview from the view to which it is attached.

Type Parameters

TResult
The type of the elements in the aggregation subview.

Return Value

The attached aggregation subview.

Remarks

This overload must be used if you have several subviews attached to the same view. The subqueryId' can be any string as long as it is not repeated for two different subviews attached to the same view.

See the other overload for the explanation of the AttachAggregationView method.

See Also

View<(Of <(T>)>) Class
AttachAggregationView Overload
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>))


AttachView Method

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachView Method
View<(Of <(T>)>) Class See Also

Overload List

Name | Description
AttachView<(Of <(TResult>)>)(Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view.
AttachView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>)) | Includes a subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view.

See Also

View<(Of <(T>)>) Class
View<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


AttachView(TResult) Method (Func(View(T), View(TResult)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachView<(Of <(TResult>)>) Method (Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>))
View<(Of <(T>)>) Class See Also
Includes a subquery into the incremental maintenance mechanism of a view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> AttachView<TResult>(
    Func<View<T>, View<TResult>> selector
)
Visual Basic (Declaration)
Public Function AttachView(Of TResult) ( _
    selector As Func(Of View(Of T), View(Of TResult)) _
) As View(Of TResult)

Parameters

selector
Type: System..::.Func <(Of <( View <(Of <( T >)>), View <(Of <(TResult>)>)>)>)
A function to obtain the attached subview from the view to which it is attached.

Type Parameters

TResult
The type of the elements in the subquery view.

Return Value

The attached subview.

Remarks

Subquery is a query inside a function that is a part of an outer query. If the outer query is a live view, and its base data changes so it needs to recompute the function, by default it just evaluates the function, which means creating a new view object for the subquery on every such recomputation. To improve performance by avoiding repeated creation and population of subviews, use the AttachView method to make the outer view aware of its subview. Then the outer view will cache and reuse subview objects it creates.

If there are more than one subviews attached to a single view, every subview must be supplied with a unique subview id by using the AttachView overload with subviewId parameter.

Examples

Copy CodeC#
var productView =
    from p in products
    join s in sales on p.ProductID equals s.ProductID into productSales
    select new
    {
        p.Name,
        SalesByCountry = productSales.AttachView(v =>
            from s in v
            group s by s.Country into countrySales
            select new
            {
                Country = countrySales.Key,
                SaleCount = countrySales.LiveSum(s => s.Quantity).Value
            })
    };

See Also

View<(Of <(T>)>) Class
AttachView Overload
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>))


AttachView(TResult) Method (Object, Func(View(T), View(TResult)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.AttachView<(Of <(TResult>)>) Method (Object, Func<(Of <(View<(Of <(T>)>), View<(Of <(TResult>)>)>)>))
View<(Of <(T>)>) Class See Also
Includes a subquery into the incremental maintenance mechanism of a view and uniquely identifies it among other subqueries of the same view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> AttachView<TResult>(
    Object subqueryId,
    Func<View<T>, View<TResult>> selector
)
Visual Basic (Declaration)
Public Function AttachView(Of TResult) ( _
    subqueryId As Object, _
    selector As Func(Of View(Of T), View(Of TResult)) _
) As View(Of TResult)

Parameters

subqueryId
Type: System..::.Object
A string uniquely specifying this subquery in the view to which it is attached. Can be any string. The only requirement is that different subqueries attached to the same view, if such exist, must have different subquery ids.
selector
Type: System..::.Func <(Of <( View <(Of <( T >)>), View <(Of <(TResult>)>)>)>)
A function to obtain the attached subview from the view to which it is attached.

Type Parameters

TResult
The type of the elements in the subquery view.

Return Value

The attached subview.

Remarks

This overload must be used if you have several subviews attached to the same view. The subqueryId can be any string as long as it is not repeated for two different subviews attached to the same view.

See the other overload for the explanation of the AttachView method.

See Also

View<(Of <(T>)>) Class
AttachView Overload
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.AttachAggregationView<(Of <(TResult>)>)(Object, Func<(Of <(View<(Of <(T>)>), AggregationView<(Of <(T, TResult>)>)>)>))


Concat Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Concat Method
View<(Of <(T>)>) Class See Also
Concatenation of two views.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<T> Concat(
    IObservableSource<T> second
)
Visual Basic (Declaration)
Public Function Concat ( _
    second As IObservableSource(Of T) _
) As View(Of T)

Parameters

second
Type: C1.LiveLinq..::.IObservableSource <(Of <( T >)>)
A collection (usually, a view) to concatenate to this view's collection of elements.

Return Value

The view that contains first the elements of this view and then the elements of the parameter collection.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Contains Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Contains Method
View<(Of <(T>)>) Class See Also
Determines whether the view contains a specified item.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains(
    T item
)
Visual Basic (Declaration)
Public Function Contains ( _
    item As T _
) As Boolean

Parameters

item
Type: T
The item to locate in the view.

Return Value

true if the view contains the specified item; otherwise, false.

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.GetEnumerator Method
View<(Of <(T>)>) Class See Also
Returns an enumerator that iterates through the view items.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerator<T> GetEnumerator()
Visual Basic (Declaration)
Public Function GetEnumerator As IEnumerator(Of T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


GroupBy Method

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>)..::.GroupBy Method
View<(Of <(T>)>) Class See Also

Overload List

Name | Description
GroupBy<(Of <(TKey>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>)) | Groups the elements of a view according to a specified key selector function.
GroupBy<(Of <(TKey, TElement>)>)(Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, TElement>)>)>)>)) | Groups the elements of a view according to a specified key selector function and projects the elements for each group by using a specified function.

See Also

View<(Of <(T>)>) Class
View<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


GroupBy(TKey) Method (Expression(Func(T, TKey)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.GroupBy<(Of <(TKey>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>))
View<(Of <(T>)>) Class See Also
Groups the elements of a view according to a specified key selector function.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<GroupView<TKey, T>> GroupBy<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function GroupBy(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As View(Of GroupView(Of TKey, T))

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract the key for each element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A view containing elements of type GroupView<(Of <(TKey, TElement>)>) each containing a key value and a view of the elements having that key value.

See Also

View<(Of <(T>)>) Class
GroupBy Overload
C1.LiveLinq.LiveViews Namespace


GroupBy(TKey, TElement) Method (Expression(Func(T, TKey)), Expression(Func(T, TElement)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.GroupBy<(Of <(TKey, TElement>)>) Method (Expression<(Of <(Func<(Of <(T, TKey>)>)>)>), Expression<(Of <(Func<(Of <(T, TElement>)>)>)>))
View<(Of <(T>)>) Class See Also
Groups the elements of a view according to a specified key selector function and projects the elements for each group by using a specified function.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<GroupView<TKey, TElement>> GroupBy<TKey, TElement>(
    Expression<Func<T, TKey>> keySelector,
    Expression<Func<T, TElement>> elementSelector
)
Visual Basic (Declaration)
Public Function GroupBy(Of TKey, TElement) ( _
    keySelector As Expression(Of Func(Of T, TKey)), _
    elementSelector As Expression(Of Func(Of T, TElement)) _
) As View(Of GroupView(Of TKey, TElement))

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract the key for each element.
elementSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TElement>)>)>)>)
A function to map each source element to a TElement.

Type Parameters

TKey
The type of the key returned by keySelector.
TElement
The type of the element to which elements of each group are projected.

Return Value

A view containing elements of type GroupView<(Of <(TKey, TElement>)>) each containing a key value and a view of the elements projected (mapped) from the elements having that key value.

See Also

View<(Of <(T>)>) Class
GroupBy Overload
C1.LiveLinq.LiveViews Namespace


GroupJoin(TInner, TKey, TResult) Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.GroupJoin<(Of <(TInner, TKey, TResult>)>) Method
View<(Of <(T>)>) Class See Also
Correlates the elements of two views based on equality of keys and groups the results.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> GroupJoin<TInner, TKey, TResult>(
    IObservableSource<TInner> inner,
    Expression<Func<T, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<T, GroupView<TKey, TInner>, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Function GroupJoin(Of TInner, TKey, TResult) ( _
    inner As IObservableSource(Of TInner), _
    outerKeySelector As Expression(Of Func(Of T, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of T, GroupView(Of TKey, TInner), TResult)) _
) As View(Of TResult)

Parameters

inner
Type: C1.LiveLinq..::.IObservableSource <(Of <(TInner>)>)
The collection (usually, a view) to join to this view.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract the join key from each element of this view.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second view.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, GroupView <(Of <(TKey, TInner>)>), TResult>)>)>)>)
A function to create a result view from an element from this view and a collection of matching elements from the second view.

Type Parameters

TInner
The type of the elements of the view to join with this view.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

A view containing elements of type TResult that are obtained by performing a grouped join on two views.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IndexOf Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IndexOf Method
View<(Of <(T>)>) Class See Also
Searches for the specified object among the elements of the view and returns the zero-based ordinal position of its first occurrence.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int IndexOf(
    T item
)
Visual Basic (Declaration)
Public Function IndexOf ( _
    item As T _
) As Integer

Parameters

item
Type: T
The object to locate in the view.

Return Value

The zero-based ordinal position of the first occurrence of item in the view, if found; otherwise, -1.

Implements

IList<(Of <(T>)>)..::.IndexOf(T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Join(TInner, TKey, TResult) Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Join<(Of <(TInner, TKey, TResult>)>) Method
View<(Of <(T>)>) Class See Also
Correlates the elements of two views based on matching keys.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> Join<TInner, TKey, TResult>(
    IObservableSource<TInner> inner,
    Expression<Func<T, TKey>> outerKeySelector,
    Expression<Func<TInner, TKey>> innerKeySelector,
    Expression<Func<T, TInner, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Function Join(Of TInner, TKey, TResult) ( _
    inner As IObservableSource(Of TInner), _
    outerKeySelector As Expression(Of Func(Of T, TKey)), _
    innerKeySelector As Expression(Of Func(Of TInner, TKey)), _
    resultSelector As Expression(Of Func(Of T, TInner, TResult)) _
) As View(Of TResult)

Parameters

inner
Type: C1.LiveLinq..::.IObservableSource <(Of <(TInner>)>)
The collection (usually, a view) to join to this view.
outerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract the join key from each element of this view.
innerKeySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <(TInner, TKey>)>)>)>)
A function to extract the join key from each element of the second view.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TInner, TResult>)>)>)>)
A function to create a result element from two matching elements.

Type Parameters

TInner
The type of the elements of the view to join with this view.
TKey
The type of the keys returned by the key selector functions.
TResult
The type of the result elements.

Return Value

A view containing elements of type TResult that are obtained by performing an inner join on two views.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderBy(TKey) Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.OrderBy<(Of <(TKey>)>) Method
View<(Of <(T>)>) Class See Also
Sorts the elements of a view in ascending order.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public OrderedView<T> OrderBy<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function OrderBy(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As OrderedView(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from an element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A view whose elements are sorted according to a key.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


OrderByDescending(TKey) Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.OrderByDescending<(Of <(TKey>)>) Method
View<(Of <(T>)>) Class See Also
Sorts the elements of a view in descending order.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public OrderedView<T> OrderByDescending<TKey>(
    Expression<Func<T, TKey>> keySelector
)
Visual Basic (Declaration)
Public Function OrderByDescending(Of TKey) ( _
    keySelector As Expression(Of Func(Of T, TKey)) _
) As OrderedView(Of T)

Parameters

keySelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TKey>)>)>)>)
A function to extract a key from an element.

Type Parameters

TKey
The type of the key returned by keySelector.

Return Value

A view whose elements are sorted in descending order according to a key.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Select(TResult) Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Select<(Of <(TResult>)>) Method
View<(Of <(T>)>) Class See Also
Projects each element of a view into a new form.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> Select<TResult>(
    Expression<Func<T, TResult>> selector
)
Visual Basic (Declaration)
Public Function Select(Of TResult) ( _
    selector As Expression(Of Func(Of T, TResult)) _
) As View(Of TResult)

Parameters

selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TResult>)>)>)>)
A transform function to apply to each element.

Type Parameters

TResult
The type of the value returned by selector.

Return Value

A view whose elements are the result of invoking the transform function on each element of this view.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


SelectMany Method

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>)..::.SelectMany Method
View<(Of <(T>)>) Class See Also

Overload List

Name | Description
SelectMany<(Of <(TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TResult>)>)>)>)>)>)) | Projects each element of this view to a collection of TResult and flattens the resulting collections into one view.
SelectMany<(Of <(TCollection, TResult>)>)(Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(T, TCollection, TResult>)>)>)>)) | Projects each element of this view to a collection of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein.

See Also

View<(Of <(T>)>) Class
View<(Of <(T>)>) Members
C1.LiveLinq.LiveViews Namespace


SelectMany(TResult) Method (Expression(Func(T, IObservableSource(TResult))))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.SelectMany<(Of <(TResult>)>) Method (Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TResult>)>)>)>)>)>))
View<(Of <(T>)>) Class See Also
Projects each element of this view to a collection of TResult and flattens the resulting collections into one view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> SelectMany<TResult>(
    Expression<Func<T, IObservableSource<TResult>>> selector
)
Visual Basic (Declaration)
Public Function SelectMany(Of TResult) ( _
    selector As Expression(Of Func(Of T, IObservableSource(Of TResult))) _
) As View(Of TResult)

Parameters

selector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IObservableSource <(Of <(TResult>)>)>)>)>)>)
A transform function to apply to each element.

Type Parameters

TResult
The type of the elements of the resulting view.

Return Value

A view whose elements are the result of invoking the one-to-many transform function on each element of this view.

See Also

View<(Of <(T>)>) Class
SelectMany Overload
C1.LiveLinq.LiveViews Namespace


SelectMany(TCollection, TResult) Method (Expression(Func(T, IObservableSource(TCollection))), Expression(Func(T, TCollection, TResult)))

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.SelectMany<(Of <(TCollection, TResult>)>) Method (Expression<(Of <(Func<(Of <(T, IObservableSource<(Of <(TCollection>)>)>)>)>)>), Expression<(Of <(Func<(Of <(T, TCollection, TResult>)>)>)>))
View<(Of <(T>)>) Class See Also
Projects each element of this view to a collection of collections, flattens the resulting collections into one collection, and invokes a result selector function on each element therein.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<TResult> SelectMany<TCollection, TResult>(
    Expression<Func<T, IObservableSource<TCollection>>> collectionSelector,
    Expression<Func<T, TCollection, TResult>> resultSelector
)
Visual Basic (Declaration)
Public Function SelectMany(Of TCollection, TResult) ( _
    collectionSelector As Expression(Of Func(Of T, IObservableSource(Of TCollection))), _
    resultSelector As Expression(Of Func(Of T, TCollection, TResult)) _
) As View(Of TResult)

Parameters

collectionSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, IObservableSource <(Of <(TCollection>)>)>)>)>)>)
A transform function to apply to each element of this view.
resultSelector
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, TCollection, TResult>)>)>)>)
A transform function to apply to each element of the intermediate collection.

Type Parameters

TCollection
The type of the intermediate elements collected by collectionSelector.
TResult
The type of the elements of the resulting view.

Return Value

A view whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of this view and then mapping each of those collection elements and their corresponding source element to a result element.

See Also

View<(Of <(T>)>) Class
SelectMany Overload
C1.LiveLinq.LiveViews Namespace


ToString Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.ToString Method
View<(Of <(T>)>) Class See Also
Returns a string representing this view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override string ToString()
Visual Basic (Declaration)
Public Overrides Function ToString As String

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Union Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Union Method
View<(Of <(T>)>) Class See Also
Set union of two views.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<T> Union(
    IObservableSource<T> second
)
Visual Basic (Declaration)
Public Function Union ( _
    second As IObservableSource(Of T) _
) As View(Of T)

Parameters

second
Type: C1.LiveLinq..::.IObservableSource <(Of <( T >)>)
A collection (usually, a view) whose distinct elements form the second set for the union.

Return Value

The view that contains the elements from both input views, excluding duplicates.

Remarks

This method excludes duplicates from the result set. This is different behavior to the Concat(IObservableSource<(Of <(T>)>)) method, which returns all the elements in the input sequences including duplicates.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Where Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Where Method
View<(Of <(T>)>) Class See Also
Filters the source view based on a predicate.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View<T> Where(
    Expression<Func<T, bool>> predicate
)
Visual Basic (Declaration)
Public Function Where ( _
    predicate As Expression(Of Func(Of T, Boolean)) _
) As View(Of T)

Parameters

predicate
Type: System.Linq.Expressions..::.Expression <(Of <( Func <(Of <( T, Boolean >)>)>)>)
A function to test each element for a condition.

Return Value

A view that contains elements of this view that satisfy the condition.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


View(T) Properties

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>) Properties
View<(Of <(T>)>) Class See Also

The View<(Of <(T>)>) type exposes the following members.

Properties

Name | Description
Count | Gets the total number of elements in the view. (Inherited from View.)
DeferredMaintenance | Gets the effective value of MaintenanceMode. (Inherited from View.)
Indexes | Gets the collection of indexes for this view.
IsReadOnly | This property overrides IsReadOnly. (Overrides View..::.IsReadOnly.)
Item | Gets the view item (element) at the specified ordinal position.
MaintenanceMode | Gets or sets a value controlling how the view is synchronized with changes in its base data. (Inherited from View.)
Order | Gets a value indicating whether and how this view preserves item order if it exists in its base data source. (Inherited from View.)
Rows | This property overrides Rows. (Overrides View..::.Rows.)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Indexes Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Indexes Property
View<(Of <(T>)>) Class See Also
Gets the collection of indexes for this view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexCollection<T> Indexes { get; }
Visual Basic (Declaration)
Public ReadOnly Property Indexes As IndexCollection(Of T)

Remarks

Live views can be indexed, just like other LiveLinq data sources, to optimize search operations over their data. For an example of an index over a view, see Live Views How To: Create Views Based on Other Views and Create Indexes on Views.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace
ViewRowCollection..::.Indexes


IsReadOnly Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IsReadOnly Property
View<(Of <(T>)>) Class See Also
This property overrides IsReadOnly.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override bool IsReadOnly { get; }
Visual Basic (Declaration)
Public Overrides ReadOnly Property IsReadOnly As Boolean

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly
IList..::.IsReadOnly

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Item Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Item Property
View<(Of <(T>)>) Class See Also
Gets the view item (element) at the specified ordinal position.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public T this[
    int ordinal
] { get; }
Visual Basic (Declaration)
Public ReadOnly Default Property Item ( _
    ordinal As Integer _
) As T

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal position of the view item.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Rows Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Rows Property
View<(Of <(T>)>) Class See Also
This property overrides Rows.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override ViewRowCollection Rows { get; }
Visual Basic (Declaration)
Public Overrides ReadOnly Property Rows As ViewRowCollection

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


View(T) Events

[image] [image]

.NET Framework Class Library
View<(Of <(T>)>) Events
View<(Of <(T>)>) Class See Also

The View<(Of <(T>)>) type exposes the following members.

Events

Name | Description
Changed | Occurs after an item of the view or the entire view has changed.
Changing | Occurs before an item of the view or the entire view changes.

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Changed Event

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Changed Event
View<(Of <(T>)>) Class See Also
Occurs after an item of the view or the entire view has changed.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<T>> Changed
Visual Basic (Declaration)
Public Event Changed As EventHandler(Of SourceChangeEventArgs(Of T))

Implements

IObservableSource<(Of <(T>)>)..::.Changed

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


Changing Event

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.Changing Event
View<(Of <(T>)>) Class See Also
Occurs before an item of the view or the entire view changes.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<T>> Changing
Visual Basic (Declaration)
Public Event Changing As EventHandler(Of SourceChangeEventArgs(Of T))

Implements

IObservableSource<(Of <(T>)>)..::.Changing

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ViewMaintenanceMode Enumeration

[image]

.NET Framework Class Library
ViewMaintenanceMode Enumeration
See Also
Specifies how a view is synchronized with changes in its base data.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum ViewMaintenanceMode
Visual Basic (Declaration)
Public Enumeration ViewMaintenanceMode

Members

Member name | Description
Default | By default, the view is in a "smart mode": It is in Deferred mode if nobody is interested in its data, and it is synchronized and goes to Immediate mode if there is a client interested in receiving notifications of changes in that view's data. In other words, a view in Default mode is effectively in Deferred mode if no listeners registered to be notified of its changes, and it is effectively in Immediate mode if there are such listeners (for example, if there is GUI control bound to it).
Deferred | When a change in base data occur, the view is not synchronized with it immediately. It is allowed to go stale, out of sync with its base data as long as there are no requests for this view's data. The view is synchronized on demand, that is, it is synchronized when any request for its data arrives.
Immediate | The view is synchronized with its base data automatically and immediately after any change in its base data occurs. The view is kept synchronized with its base data at all times.

Remarks

See Also: View Maintenance Mode.

See Also

C1.LiveLinq.LiveViews Namespace
View..::.MaintenanceMode
View..::.DeferredMaintenance


ViewOrder Enumeration

[image]

.NET Framework Class Library
ViewOrder Enumeration
See Also
Specifies whether and how a view must preserve item order if it exists in the source.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum ViewOrder
Visual Basic (Declaration)
Public Enumeration ViewOrder

Members

Member name | Description
Preserved | Source order is preserved completely. Order of items in the view is always the same as in the source (if source has a particular order), even after the view is maintained to reflect changes that occurred in the source.
PartiallyPreserved | Source order is partially preserved. When the view is created, it preserves source order, but later, when changes occur in the source, view items added or modified to reflect those changes aren't guaranteed to appear at the same order position in the view as in the source.
Unordered | Source order is not preserved. Preserving source order is not guaranteed even at view creation.

See Also

C1.LiveLinq.LiveViews Namespace


ViewRow Class

[image]

.NET Framework Class Library
ViewRow Class
Members See Also
Represents a view element (item) for the purposes of dynamic, programmatic access to its properties and data binding.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class ViewRow : IndexableObject,
    IEditableObject, ICustomTypeDescriptor
Visual Basic (Declaration)
Public MustInherit Class ViewRow _
    Inherits IndexableObject _
    Implements IEditableObject, ICustomTypeDescriptor

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.Collections..::.IndexableObject
C1.LiveLinq.LiveViews..::.ViewRow

See Also

ViewRow Members
C1.LiveLinq.LiveViews Namespace
View..::.Rows


ViewRow Members

[image] [image]

.NET Framework Class Library
ViewRow Members
ViewRow Class Methods Properties Events See Also

The ViewRow type exposes the following members.

Methods

Name | Description
BeginEdit | Puts the ViewRow into edit mode.
CancelEdit | Cancels the edit occurring on the row.
Delete | Deletes a view item.
EndEdit | Ends the edit occurring on the row.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event. (Inherited from IndexableObject.)
OnPropertyChanging | Raises the PropertyChanging event. (Inherited from IndexableObject.)
ToString | Gets the string representing this view row. (Overrides Object..::.ToString()()().)

Properties

Name | Description
Item | Overloaded.
RowState | Gets the state of a view row with regard to edit, add and delete operations if they are performed directly on the view.
Tag | Gets or sets user-supplied data associated with the view item.
Value | Gets the view element (item) represented by this ViewRow object.
View | Gets the view to which the ViewRow belongs.

Events

Name | Description
PropertyChanged | Occurs when a property value changes, after it has been changed. (Inherited from IndexableObject.)
PropertyChanging | Occurs when a property value is changing, before it has been changed. (Inherited from IndexableObject.)

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ViewRow Methods

[image] [image]

.NET Framework Class Library
ViewRow Methods
ViewRow Class See Also

The ViewRow type exposes the following members.

Methods

Name | Description
BeginEdit | Puts the ViewRow into edit mode.
CancelEdit | Cancels the edit occurring on the row.
Delete | Deletes a view item.
EndEdit | Ends the edit occurring on the row.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
OnPropertyChanged | Raises the PropertyChanged event. (Inherited from IndexableObject.)
OnPropertyChanging | Raises the PropertyChanging event. (Inherited from IndexableObject.)
ToString | Gets the string representing this view row. (Overrides Object..::.ToString()()().)

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


BeginEdit Method

[image]

.NET Framework Class Library
ViewRow..::.BeginEdit Method
ViewRow Class See Also
Puts the ViewRow into edit mode.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void BeginEdit()
Visual Basic (Declaration)
Public Sub BeginEdit

Remarks

In edit mode, events and notifications are temporarily suspended, letting the user make changes to more than one property without triggering validation rules.

Edit mode is a standard feature of .NET data binding mechanism, supported by every data source implementing the IEditableObject interface. For detailed explanation, see, for example, DataRowView in .NET Framework documentation.

While a view item is in edit mode, changes made to its updatable properties directly in the view are not propagated to the corresponding base data properties until the edit operation is completed by a call to EndEdit()()() (see IsReadOnly about updatability of view element properties directly in the view).

If you change base data (source) properties, those changes are propagated to this view and other views depending on that base data according to the normal view maintenance process, regardless of whether the view row is in edit mode or not.

Many-to-one relations between view properties are maintained automatically on changes made to updatable properties directly in the view, regardless of whether the view row is in edit mode or not. For example, if you set a CustomerID directly in the view, CustomerName will change accordingly, even if you do it in edit mode.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


CancelEdit Method

[image]

.NET Framework Class Library
ViewRow..::.CancelEdit Method
ViewRow Class See Also
Cancels the edit occurring on the row.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void CancelEdit()
Visual Basic (Declaration)
Public Overridable Sub CancelEdit

Remarks

If the user set some of the updatable properties of the row while it was in edit mode, the changes to those properties are rolled back and not propagated to the corresponding base data properties.

See the BeginEdit()()() method for more information.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


Delete Method

[image]

.NET Framework Class Library
ViewRow..::.Delete Method
ViewRow Class See Also
Deletes a view item.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void Delete()
Visual Basic (Declaration)
Public Overridable Sub Delete

Remarks

Deleting a view item is an update operation on the view. As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly), and it results in updating (in this case, deleting an item from) one of the view's base data collections.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


EndEdit Method

[image]

.NET Framework Class Library
ViewRow..::.EndEdit Method
ViewRow Class See Also
Ends the edit occurring on the row.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public virtual void EndEdit()
Visual Basic (Declaration)
Public Overridable Sub EndEdit

Remarks

If the user set some of the updatable properties of the row while it was in edit mode, the changes to those properties are propagated to the corresponding base data properties at this point.

See the BeginEdit()()() method for more information.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ToString Method

[image]

.NET Framework Class Library
ViewRow..::.ToString Method
ViewRow Class See Also
Gets the string representing this view row.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public override string ToString()
Visual Basic (Declaration)
Public Overrides Function ToString As String

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ViewRow Properties

[image] [image]

.NET Framework Class Library
ViewRow Properties
ViewRow Class See Also

The ViewRow type exposes the following members.

Properties

Name | Description
Item | Overloaded.
RowState | Gets the state of a view row with regard to edit, add and delete operations if they are performed directly on the view.
Tag | Gets or sets user-supplied data associated with the view item.
Value | Gets the view element (item) represented by this ViewRow object.
View | Gets the view to which the ViewRow belongs.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


Item Property

[image] [image]

.NET Framework Class Library
ViewRow..::.Item Property
ViewRow Class See Also

Overload List

Name | Description
Item[([(PropertyDescriptor])]) | Gets or sets a value of the specified view property.
Item[([(Int32])]) | Gets or sets a value of the specified view property.
Item[([(String])]) | Gets or sets a value of the specified view property.

See Also

ViewRow Class
ViewRow Members
C1.LiveLinq.LiveViews Namespace


Item Property (PropertyDescriptor)

[image]

.NET Framework Class Library
ViewRow..::.Item Property (PropertyDescriptor)
ViewRow Class See Also
Gets or sets a value of the specified view property.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Object this[
    PropertyDescriptor propertyDescriptor
] { get; set; }
Visual Basic (Declaration)
Public Default Property Item ( _
    propertyDescriptor As PropertyDescriptor _
) As Object

Parameters

propertyDescriptor
Type: System.ComponentModel..::.PropertyDescriptor
The property to access.

Return Value

The value of the property.

Remarks

Setting a view property is an update operation on the view. As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly), and it results in updating one of the view's base data collections.

Only updatable properties can be set. An attempt to set a read-only property results in an exception. See IsReadOnly for more details.

See Also

ViewRow Class
Item Overload
C1.LiveLinq.LiveViews Namespace


Item Property (Int32)

[image]

.NET Framework Class Library
ViewRow..::.Item Property (Int32)
ViewRow Class See Also
Gets or sets a value of the specified view property.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Object this[
    int propertyOrdinal
] { get; set; }
Visual Basic (Declaration)
Public Default Property Item ( _
    propertyOrdinal As Integer _
) As Object

Parameters

propertyOrdinal
Type: System..::.Int32
The ordinal position of the property in the collection of public properties of the type of the view element.

Return Value

The value of the property.

Remarks

Setting a view property is an update operation on the view. As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly), and it results in updating one of the view's base data collections.

Only updatable properties can be set. An attempt to set a read-only property results in an exception. See IsReadOnly for more details.

See Also

ViewRow Class
Item Overload
C1.LiveLinq.LiveViews Namespace


Item Property (String)

[image]

.NET Framework Class Library
ViewRow..::.Item Property (String)
ViewRow Class See Also
Gets or sets a value of the specified view property.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Object this[
    string propertyName
] { get; set; }
Visual Basic (Declaration)
Public Default Property Item ( _
    propertyName As String _
) As Object

Parameters

propertyName
Type: System..::.String
The name of the property.

Return Value

The value of the property.

Remarks

Setting a view property is an update operation on the view. As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly), and it results in updating one of the view's base data collections.

Only updatable properties can be set. An attempt to set a read-only property results in an exception. See IsReadOnly for more details.

See Also

ViewRow Class
Item Overload
C1.LiveLinq.LiveViews Namespace


RowState Property

[image]

.NET Framework Class Library
ViewRow..::.RowState Property
ViewRow Class See Also
Gets the state of a view row with regard to edit, add and delete operations if they are performed directly on the view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ViewRowState RowState { get; }
Visual Basic (Declaration)
Public ReadOnly Property RowState As ViewRowState

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


Tag Property

[image]

.NET Framework Class Library
ViewRow..::.Tag Property
ViewRow Class See Also
Gets or sets user-supplied data associated with the view item.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public Object Tag { get; set; }
Visual Basic (Declaration)
Public Property Tag As Object

Remarks

Use this property to store any object you want to associate in your code with the view item that you need to access quickly.

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


Value Property

[image]

.NET Framework Class Library
ViewRow..::.Value Property
ViewRow Class See Also
Gets the view element (item) represented by this ViewRow object.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract Object Value { get; }
Visual Basic (Declaration)
Public MustOverride ReadOnly Property Value As Object

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


View Property

[image]

.NET Framework Class Library
ViewRow..::.View Property
ViewRow Class See Also
Gets the view to which the ViewRow belongs.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public View View { get; }
Visual Basic (Declaration)
Public ReadOnly Property View As View

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ViewRow Events

[image] [image]

.NET Framework Class Library
ViewRow Events
ViewRow Class See Also

The ViewRow type exposes the following members.

Events

Name | Description
PropertyChanged | Occurs when a property value changes, after it has been changed. (Inherited from IndexableObject.)
PropertyChanging | Occurs when a property value is changing, before it has been changed. (Inherited from IndexableObject.)

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ViewRowAddingEventArgs Class

[image]

.NET Framework Class Library
ViewRowAddingEventArgs Class
Members See Also
Provides data for the ViewRowAdding event.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public class ViewRowAddingEventArgs : EventArgs
Visual Basic (Declaration)
Public Class ViewRowAddingEventArgs _
    Inherits EventArgs

Inheritance Hierarchy

System..::.Object
System..::.EventArgs
C1.LiveLinq.LiveViews..::.ViewRowAddingEventArgs

See Also

ViewRowAddingEventArgs Members
C1.LiveLinq.LiveViews Namespace


ViewRowAddingEventArgs Members

[image] [image]

.NET Framework Class Library
ViewRowAddingEventArgs Members
ViewRowAddingEventArgs Class Methods Properties See Also

The ViewRowAddingEventArgs type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
Row | Gets the new view row that has just been added to ViewRowCollection.

See Also

ViewRowAddingEventArgs Class
C1.LiveLinq.LiveViews Namespace


ViewRowAddingEventArgs Methods

[image] [image]

.NET Framework Class Library
ViewRowAddingEventArgs Methods
ViewRowAddingEventArgs Class See Also

The ViewRowAddingEventArgs type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

ViewRowAddingEventArgs Class
C1.LiveLinq.LiveViews Namespace


ViewRowAddingEventArgs Properties

[image] [image]

.NET Framework Class Library
ViewRowAddingEventArgs Properties
ViewRowAddingEventArgs Class See Also

The ViewRowAddingEventArgs type exposes the following members.

Properties

Name | Description
Row | Gets the new view row that has just been added to ViewRowCollection.

See Also

ViewRowAddingEventArgs Class
C1.LiveLinq.LiveViews Namespace


Row Property

[image]

.NET Framework Class Library
ViewRowAddingEventArgs..::.Row Property
ViewRowAddingEventArgs Class See Also
Gets the new view row that has just been added to ViewRowCollection.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ViewRow Row { get; private set; }
Visual Basic (Declaration)
Public Property Row As ViewRow

See Also

ViewRowAddingEventArgs Class
C1.LiveLinq.LiveViews Namespace


ViewRowCollection Class

[image]

.NET Framework Class Library
ViewRowCollection Class
Members See Also
Represents a collection of ViewRow objects used for programmatic access to view elements (items) and for data binding.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class ViewRowCollection : IObservableSource<ViewRow>,
    IIndexedSource<ViewRow>, IBindingList, ITypedList, ICancelAddNew,
    INotifyPropertyChanged, IList<ViewRow>, ICollection<ViewRow>,
    IEnumerable<ViewRow>, IList, ICollection, IEnumerable
Visual Basic (Declaration)
Public MustInherit Class ViewRowCollection _
    Implements IObservableSource(Of ViewRow), IIndexedSource(Of ViewRow),  _
    IBindingList, ITypedList, ICancelAddNew, INotifyPropertyChanged, IList(Of ViewRow),  _
    ICollection(Of ViewRow), IEnumerable(Of ViewRow), IList,  _
    ICollection, IEnumerable

Remarks

A ViewRowCollection is owned by a view, see Rows.

The collection of view rows (ViewRow objects) is always synchronized with the collection of view elements.

ViewRow objects provide programmatic access to view elements and their properties. Also, the Rows collection serves as the data source for data binding, when you bind a control or another client to a view.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews..::.ViewRowCollection

See Also

ViewRowCollection Members
C1.LiveLinq.LiveViews Namespace


ViewRowCollection Members

[image] [image]

.NET Framework Class Library
ViewRowCollection Members
ViewRowCollection Class Methods Properties Events See Also

The ViewRowCollection type exposes the following members.

Methods

Name | Description
Clear | Deletes all view elements.
Contains | Determines whether the ViewRowCollection contains a specific view row.
CreateRow | Creates a new item directly in the view, and a view row associated with it, and adds it to the ViewRowCollection.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through view rows.
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetItemProperties | Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.
GetType | Gets the Type of the current instance. (Inherited from Object.)
IndexOf | Determines the ordinal position of a specific view row in the ViewRowCollection.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Deletes the specified view item.
RemoveAt | Deletes the view row at a specified ordinal position in ViewRowCollection.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Properties

Name | Description
AllowClear | Gets a value indicating whether the Clear()()() operation is allowed on the view directly.
AllowEdit | Gets a value indicating whether modifying property values is allowed on the view directly.
AllowNew | Gets a value indicating whether the CreateRow()()() operation is allowed on the view directly.
AllowRemove | Gets a value indicating whether deleting rows is allowed on the view directly.
Count | Gets the number of elements in the view.
Indexes | Gets the collection of indexes for this view allowing to search for ViewRow objects.
Item | Gets the view row at the specified ordinal position.
Properties | Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.

Events

Name | Description
Changed | Occurs after a view row has changed.
Changing | Occurs before a a view row changes.
ViewRowAdding | Occurs after a new view row is created so it can be populated with default values.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ViewRowCollection Methods

[image] [image]

.NET Framework Class Library
ViewRowCollection Methods
ViewRowCollection Class See Also

The ViewRowCollection type exposes the following members.

Methods

Name | Description
Clear | Deletes all view elements.
Contains | Determines whether the ViewRowCollection contains a specific view row.
CreateRow | Creates a new item directly in the view, and a view row associated with it, and adds it to the ViewRowCollection.
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetEnumerator | Returns an enumerator that iterates through view rows.
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetItemProperties | Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.
GetType | Gets the Type of the current instance. (Inherited from Object.)
IndexOf | Determines the ordinal position of a specific view row in the ViewRowCollection.
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
Remove | Deletes the specified view item.
RemoveAt | Deletes the view row at a specified ordinal position in ViewRowCollection.
ToString | Returns a String that represents the current Object. (Inherited from Object.)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Clear Method

[image]

.NET Framework Class Library
ViewRowCollection..::.Clear Method
ViewRowCollection Class See Also
Deletes all view elements.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void Clear()
Visual Basic (Declaration)
Public Sub Clear

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Contains Method

[image]

.NET Framework Class Library
ViewRowCollection..::.Contains Method
ViewRowCollection Class See Also
Determines whether the ViewRowCollection contains a specific view row.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Contains(
    ViewRow row
)
Visual Basic (Declaration)
Public Function Contains ( _
    row As ViewRow _
) As Boolean

Parameters

row
Type: C1.LiveLinq.LiveViews..::.ViewRow
The view row to locate in the collection.

Return Value

true if the view row is found in the collection; otherwise, false.

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


CreateRow Method

[image]

.NET Framework Class Library
ViewRowCollection..::.CreateRow Method
ViewRowCollection Class See Also
Creates a new item directly in the view, and a view row associated with it, and adds it to the ViewRowCollection.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ViewRow CreateRow()
Visual Basic (Declaration)
Public Function CreateRow As ViewRow

Return Value

The newly created view row.

Remarks

Creating a new row is an update operation on the view. As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly), and it results in updating (in this case, adding a new item to) one of the view's base data collections.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


GetEnumerator Method

[image]

.NET Framework Class Library
ViewRowCollection..::.GetEnumerator Method
ViewRowCollection Class See Also
Returns an enumerator that iterates through view rows.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IEnumerator GetEnumerator()
Visual Basic (Declaration)
Public Function GetEnumerator As IEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


GetItemProperties Method

[image]

.NET Framework Class Library
ViewRowCollection..::.GetItemProperties Method
ViewRowCollection Class See Also
Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public PropertyDescriptorCollection GetItemProperties(
    PropertyDescriptor[] listAccessors
)
Visual Basic (Declaration)
Public Function GetItemProperties ( _
    listAccessors As PropertyDescriptor() _
) As PropertyDescriptorCollection

Parameters

listAccessors
Type: array< System.ComponentModel..::.PropertyDescriptor >[]()[]
An array of PropertyDescriptor objects to find in the collection as bindable. Can be null.

Implements

ITypedList..::.GetItemProperties(array<PropertyDescriptor>[]()[])

Remarks

If listAccessors is null, this method returns the collection of properties of the view element type.

Non-null listAccessors is used for obtaining property collection for hierarchical binding: If listAccessors contains a single element, then it is used to find an object-valued property in the element type, and the collection of properties of the type of that object-valued property is returned. If listAccessors contains two elements, then its second element is used to find an object-valued property in the collection of properties on the previous level, and so on, see ITypedList.GetItemProperties for more information.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IndexOf Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IndexOf Method
ViewRowCollection Class See Also
Determines the ordinal position of a specific view row in the ViewRowCollection.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int IndexOf(
    ViewRow row
)
Visual Basic (Declaration)
Public Function IndexOf ( _
    row As ViewRow _
) As Integer

Parameters

row
Type: C1.LiveLinq.LiveViews..::.ViewRow
The view row to locate in the collection.

Return Value

The ordinal position of the view row in the collection if it is found; otherwise, -1.

Implements

IList<(Of <(T>)>)..::.IndexOf(T)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Remove Method

[image]

.NET Framework Class Library
ViewRowCollection..::.Remove Method
ViewRowCollection Class See Also
Deletes the specified view item.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool Remove(
    ViewRow row
)
Visual Basic (Declaration)
Public Function Remove ( _
    row As ViewRow _
) As Boolean

Parameters

row
Type: C1.LiveLinq.LiveViews..::.ViewRow
The view row representing the item to delete.

Return Value

true, if the item was deleted as a result of this operation; otherwise, false.

Remarks

This is an update operation on the view equivalent to calling Delete()()().

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


RemoveAt Method

[image]

.NET Framework Class Library
ViewRowCollection..::.RemoveAt Method
ViewRowCollection Class See Also
Deletes the view row at a specified ordinal position in ViewRowCollection.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public void RemoveAt(
    int ordinal
)
Visual Basic (Declaration)
Public Sub RemoveAt ( _
    ordinal As Integer _
)

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal position of the item to remove.

Remarks

This is an update operation on the view equivalent to calling Delete()()().

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ViewRowCollection Properties

[image] [image]

.NET Framework Class Library
ViewRowCollection Properties
ViewRowCollection Class See Also

The ViewRowCollection type exposes the following members.

Properties

Name | Description
AllowClear | Gets a value indicating whether the Clear()()() operation is allowed on the view directly.
AllowEdit | Gets a value indicating whether modifying property values is allowed on the view directly.
AllowNew | Gets a value indicating whether the CreateRow()()() operation is allowed on the view directly.
AllowRemove | Gets a value indicating whether deleting rows is allowed on the view directly.
Count | Gets the number of elements in the view.
Indexes | Gets the collection of indexes for this view allowing to search for ViewRow objects.
Item | Gets the view row at the specified ordinal position.
Properties | Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


AllowClear Property

[image]

.NET Framework Class Library
ViewRowCollection..::.AllowClear Property
ViewRowCollection Class See Also
Gets a value indicating whether the Clear()()() operation is allowed on the view directly.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool AllowClear { get; }
Visual Basic (Declaration)
Public ReadOnly Property AllowClear As Boolean

Remarks

As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly). Note that the same operation is often allowed on the base data collection, and it will normally result in the corresponding change of the view.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


AllowEdit Property

[image]

.NET Framework Class Library
ViewRowCollection..::.AllowEdit Property
ViewRowCollection Class See Also
Gets a value indicating whether modifying property values is allowed on the view directly.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool AllowEdit { get; }
Visual Basic (Declaration)
Public ReadOnly Property AllowEdit As Boolean

Implements

IBindingList..::.AllowEdit

Remarks

As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly).

Although read-only properties of a view cannot be modified directly in the view, they still reflect up-to-date values of the source, so the difference is often not critical, you can always modify corresponding property in the source, that will automatically change the property in the view.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


AllowNew Property

[image]

.NET Framework Class Library
ViewRowCollection..::.AllowNew Property
ViewRowCollection Class See Also
Gets a value indicating whether the CreateRow()()() operation is allowed on the view directly.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool AllowNew { get; }
Visual Basic (Declaration)
Public ReadOnly Property AllowNew As Boolean

Implements

IBindingList..::.AllowNew

Remarks

As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly). Note that the same operation is usually allowed on the base data collection, and it will normally result in the corresponding change of the view.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


AllowRemove Property

[image]

.NET Framework Class Library
ViewRowCollection..::.AllowRemove Property
ViewRowCollection Class See Also
Gets a value indicating whether deleting rows is allowed on the view directly.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public bool AllowRemove { get; }
Visual Basic (Declaration)
Public ReadOnly Property AllowRemove As Boolean

Implements

IBindingList..::.AllowRemove

Remarks

As any other update operation performed directly on the view (as opposed to on the base data collection on which that view depends, see AsUpdatable<(Of <(T>)>)(View<(Of <(T>)>))), it is allowed only if the view is not read-only (see IsReadOnly). Note that the same operation is often allowed on the base data collection, and it will normally result in the corresponding change of the view.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Count Property

[image]

.NET Framework Class Library
ViewRowCollection..::.Count Property
ViewRowCollection Class See Also
Gets the number of elements in the view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public int Count { get; }
Visual Basic (Declaration)
Public ReadOnly Property Count As Integer

Implements

ICollection<(Of <(T>)>)..::.Count
ICollection..::.Count

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Indexes Property

[image]

.NET Framework Class Library
ViewRowCollection..::.Indexes Property
ViewRowCollection Class See Also
Gets the collection of indexes for this view allowing to search for ViewRow objects.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public IndexCollection<ViewRow> Indexes { get; }
Visual Basic (Declaration)
Public ReadOnly Property Indexes As IndexCollection(Of ViewRow)

Remarks

ViewRowCollection can be indexed, just like other LiveLinq data sources, to optimize searches for ViewRow objects. It implements the IIndexedSource<(Of <(T>)>) interface.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace
View<(Of <(T>)>)..::.Indexes


Item Property

[image]

.NET Framework Class Library
ViewRowCollection..::.Item Property
ViewRowCollection Class See Also
Gets the view row at the specified ordinal position.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public ViewRow this[
    int ordinal
] { get; }
Visual Basic (Declaration)
Public ReadOnly Default Property Item ( _
    ordinal As Integer _
) As ViewRow

Parameters

ordinal
Type: System..::.Int32
The zero-based ordinal position of the view row.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Properties Property

[image]

.NET Framework Class Library
ViewRowCollection..::.Properties Property
ViewRowCollection Class See Also
Returns the collection of properties available in the view element type to programmatic access through ViewRow and to data binding.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public PropertyDescriptorCollection Properties { get; }
Visual Basic (Declaration)
Public ReadOnly Property Properties As PropertyDescriptorCollection

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ViewRowCollection Events

[image] [image]

.NET Framework Class Library
ViewRowCollection Events
ViewRowCollection Class See Also

The ViewRowCollection type exposes the following members.

Events

Name | Description
Changed | Occurs after a view row has changed.
Changing | Occurs before a a view row changes.
ViewRowAdding | Occurs after a new view row is created so it can be populated with default values.

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Changed Event

[image]

.NET Framework Class Library
ViewRowCollection..::.Changed Event
ViewRowCollection Class See Also
Occurs after a view row has changed.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<ViewRow>> Changed
Visual Basic (Declaration)
Public Event Changed As EventHandler(Of SourceChangeEventArgs(Of ViewRow))

Implements

IObservableSource<(Of <(T>)>)..::.Changed

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


Changing Event

[image]

.NET Framework Class Library
ViewRowCollection..::.Changing Event
ViewRowCollection Class See Also
Occurs before a a view row changes.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<SourceChangeEventArgs<ViewRow>> Changing
Visual Basic (Declaration)
Public Event Changing As EventHandler(Of SourceChangeEventArgs(Of ViewRow))

Implements

IObservableSource<(Of <(T>)>)..::.Changing

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ViewRowAdding Event

[image]

.NET Framework Class Library
ViewRowCollection..::.ViewRowAdding Event
ViewRowCollection Class See Also
Occurs after a new view row is created so it can be populated with default values.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public event EventHandler<ViewRowAddingEventArgs> ViewRowAdding
Visual Basic (Declaration)
Public Event ViewRowAdding As EventHandler(Of ViewRowAddingEventArgs)

Remarks

This event occurs only if the new row is created directly in the view, as a result of a view update operation, that is, with CreateRow()()() or via data binding. It does not occur when new rows appear in the view as a result of view maintenance on changes made to the view's source data collections.

This event occurs immediately on creating the new row, before the method creating it returns, before the row enters edit mode (see ViewRowState about edit mode).

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ViewRowState Enumeration

[image]

.NET Framework Class Library
ViewRowState Enumeration
See Also
The state of a view row with regard to edit, add and delete operations if they are performed directly on the view.

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public enum ViewRowState
Visual Basic (Declaration)
Public Enumeration ViewRowState

Members

Member name | Description
Unmodified | The row is a regular view row, not in edit mode and not deleted.
Modified | The row is in edit mode (BeginEdit()()() was called, neither EndEdit()()() nor CancelEdit()()() was called yet), and the row is not new (was not created by CreateRow()()()).
New | The row was added to the view directly (not by adding to a basic data collection) by calling CreateRow()()() or through data binding (such new row enters edit mode once it is created) and still in edit mode (neither EndEdit()()() nor CancelEdit()()() was called yet).
Detached | The row was deleted, or it is a new row after exiting edit mode.

Remarks

This state concerns edit, add and delete operations performed directly on the view (programmatically via ViewRow objects or through data binding). It does not concern modifications made to the view's base (source) data collections. Modifications made to source data can also change view items, as a result of the normal view maintenance process, see MaintenanceMode, but in that case the state of thus added or modified rows remains Unmodified.

Note on adding rows directly to the view:

If a row is added directly to the view (as opposed to adding it to one of its base data collections), the following happens:

When a new row is created with CreateRow()()() or through data binding, it enters edit mode.

When it is committed with EndEdit()()(), a new row is added to the view's base data collection, and, usually, a corresponding row appears in the view, that has Unmodified state, although in some cases it may be more than one row or none, depending on the view query. The original view row no longer corresponds to a view item after the EndEdit()()() or CancelEdit()()() call, its state becomes Detached. Accessing it after that would throw an exception.

See Also

C1.LiveLinq.LiveViews Namespace


C1.LiveLinq.LiveViews.Xml Namespace

[image]

.NET Framework Class Library
C1.LiveLinq.LiveViews.Xml Namespace

Classes

Class | Description
XHint | The class used for the return type in the IndexedElement(XContainer, XName) and IndexedAttribute(XElement, XName) extension methods.
XmlExtensions | Provides a set of static (extension) methods for LiveLinq to XML.


XHint Class

[image]

.NET Framework Class Library
XHint Class
Members See Also
The class used for the return type in the IndexedElement(XContainer, XName) and IndexedAttribute(XElement, XName) extension methods.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public abstract class XHint
Visual Basic (Declaration)
Public MustInherit Class XHint

Remarks

This class is not used in execution, because hints like IndexedElement(XContainer, XName) and IndexedAttribute(XElement, XName) are never executed, they are used merely to convey information ('hint') to LiveLinq query optimizer, they are discarded before the query is executed. The only purpose of this class is to preserve syntactical correctness of the query.

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews.Xml..::.XHint

See Also

XHint Members
C1.LiveLinq.LiveViews.Xml Namespace


XHint Members

[image] [image]

.NET Framework Class Library
XHint Members
XHint Class Methods See Also

The XHint type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Operators

Name | Description
Explicit | Overloaded.

See Also

XHint Class
C1.LiveLinq.LiveViews.Xml Namespace


XHint Methods

[image] [image]

.NET Framework Class Library
XHint Methods
XHint Class See Also

The XHint type exposes the following members.

Methods

Name | Description
Equals | Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
Finalize | Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection. (Inherited from Object.)
GetHashCode | Serves as a hash function for a particular type. (Inherited from Object.)
GetType | Gets the Type of the current instance. (Inherited from Object.)
MemberwiseClone | Creates a shallow copy of the current Object. (Inherited from Object.)
ToString | Returns a String that represents the current Object. (Inherited from Object.)

Operators

Name | Description
Explicit | Overloaded.

See Also

XHint Class
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Method

[image] [image]

.NET Framework Class Library
XHint..::.Explicit Method
XHint Class See Also

Overload List

Name | Description
Explicit(XHint) | Converts the specified XHint to a nullable Int64.
Explicit(XHint) | Converts the specified XHint to a nullable UInt64.
Explicit(XHint) | Converts the specified XHint to a nullable Single.
Explicit(XHint) | Converts the specified XHint to a nullable Boolean.
Explicit(XHint) | Converts the specified XHint to a nullable Int32.
Explicit(XHint) | Converts the specified XHint to a nullable UInt32.
Explicit(XHint) | Converts the specified XHint to a nullable DateTimeOffset.
Explicit(XHint) | Converts the specified XHint to a nullable TimeSpan.
Explicit(XHint) | Converts the specified XHint to a nullable Guid.
Explicit(XHint) | Converts the specified XHint to a nullable Double.
Explicit(XHint) | Converts the specified XHint to a nullable Decimal.
Explicit(XHint) | Converts the specified XHint to a nullable DateTime.
Explicit(XHint) | Converts the specified XHint to a Guid.
Explicit(XHint) | Converts the specified XHint to a UInt32.
Explicit(XHint) | Converts the specified XHint to a Int64.
Explicit(XHint) | Converts the specified XHint to a UInt64.
Explicit(XHint) | Converts the specified XHint to a String.
Explicit(XHint) | Converts the specified XHint to a Boolean.
Explicit(XHint) | Converts the specified XHint to a Int32.
Explicit(XHint) | Converts the specified XHint to a DateTime.
Explicit(XHint) | Converts the specified XHint to a DateTimeOffset.
Explicit(XHint) | Converts the specified XHint to a TimeSpan.
Explicit(XHint) | Converts the specified XHint to a Single.
Explicit(XHint) | Converts the specified XHint to a Double.
Explicit(XHint) | Converts the specified XHint to a Decimal.

See Also

XHint Class
XHint Members
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Int64.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<long> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Long)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Int64 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable UInt64.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<ulong> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of ULong)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable UInt64 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Single.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<float> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Single)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Single to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Boolean.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<bool> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Boolean)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Boolean to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Int32.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<int> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Integer)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Int32 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable UInt32.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<uint> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of UInteger)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable UInt32 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable DateTimeOffset.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<DateTimeOffset> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of DateTimeOffset)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable DateTimeOffset to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable TimeSpan.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<TimeSpan> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of TimeSpan)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable TimeSpan to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Guid.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<Guid> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Guid)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Guid to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Double.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<double> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Double)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Double to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable Decimal.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<decimal> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of Decimal)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable Decimal to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a nullable DateTime.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Nullable<DateTime> (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Nullable(Of DateTime)

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The nullable DateTime to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Guid.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator Guid (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Guid

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Guid to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a UInt32.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator uint (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As UInteger

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The UInt32 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Int64.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator long (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Long

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Int64 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a UInt64.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator ulong (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As ULong

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The UInt64 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a String.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator string (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As String

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The String to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Boolean.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator bool (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Boolean

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Boolean to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Int32.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator int (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Integer

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Int32 to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a DateTime.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator DateTime (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As DateTime

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The DateTime to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a DateTimeOffset.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator DateTimeOffset (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As DateTimeOffset

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The DateTimeOffset to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a TimeSpan.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator TimeSpan (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As TimeSpan

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The TimeSpan to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Single.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator float (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Single

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Single to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Double.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator double (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Double

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Double to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


Explicit Operator

[image]

.NET Framework Class Library
XHint..::.Explicit Operator
XHint Class See Also
Converts the specified XHint to a Decimal.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static explicit operator decimal (
    XHint hint
)
Visual Basic (Declaration)
Public Shared Narrowing Operator CType ( _
    hint As XHint _
) As Decimal

Parameters

hint
Type: C1.LiveLinq.LiveViews.Xml..::.XHint
The XHint to convert.

Return Value

The Decimal to which this operator converts.

See Also

XHint Class
Explicit Overload
C1.LiveLinq.LiveViews.Xml Namespace


XmlExtensions Class

[image]

.NET Framework Class Library
XmlExtensions Class
Members See Also
Provides a set of static (extension) methods for LiveLinq to XML.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class XmlExtensions
Visual Basic (Declaration)
Public NotInheritable Class XmlExtensions

Inheritance Hierarchy

System..::.Object
C1.LiveLinq.LiveViews.Xml..::.XmlExtensions

See Also

XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


XmlExtensions Members

[image] [image]

.NET Framework Class Library
XmlExtensions Members
XmlExtensions Class Methods See Also

The XmlExtensions type exposes the following members.

Methods

Name | Description
AsLive | Overloaded.
Attributes | Overloaded.
BeginUpdate | Suspends notifications while massive changes are being made to an XML node and its descendants.
DescendantNodes<(Of <(T>)>) | Returns a view representing the collection of the descendent nodes of every element and document in the source view.
DescendantNodesAndSelf | Returns a view representing the collection of nodes that contains every element in the source view, and the descendent nodes of every element in the source view.
Descendants | Overloaded.
DescendantsAndSelf | Overloaded.
Elements | Overloaded.
EndUpdate | Ends notification suspension started with BeginUpdate(XContainer).
IndexedAttribute | Overloaded.
IndexedElement | Overloaded.
Nodes<(Of <(T>)>) | Returns a view representing the collection of child nodes of every document and element in the source view.
Root | Gets the view for the root element of the XML tree for this document.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


XmlExtensions Methods

[image] [image]

.NET Framework Class Library
XmlExtensions Methods
XmlExtensions Class See Also

The XmlExtensions type exposes the following members.

Methods

Name | Description
AsLive | Overloaded.
Attributes | Overloaded.
BeginUpdate | Suspends notifications while massive changes are being made to an XML node and its descendants.
DescendantNodes<(Of <(T>)>) | Returns a view representing the collection of the descendent nodes of every element and document in the source view.
DescendantNodesAndSelf | Returns a view representing the collection of nodes that contains every element in the source view, and the descendent nodes of every element in the source view.
Descendants | Overloaded.
DescendantsAndSelf | Overloaded.
Elements | Overloaded.
EndUpdate | Ends notification suspension started with BeginUpdate(XContainer).
IndexedAttribute | Overloaded.
IndexedElement | Overloaded.
Nodes<(Of <(T>)>) | Returns a view representing the collection of child nodes of every document and element in the source view.
Root | Gets the view for the root element of the XML tree for this document.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


AsLive Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.AsLive Method
XmlExtensions Class See Also

Overload List

Name | Description
AsLive(XDocument) | Creates a view based on the specified XML document.
AsLive(XElement) | Creates a view based on the specified XML element.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


AsLive Method (XDocument)

[image]

.NET Framework Class Library
XmlExtensions..::.AsLive Method (XDocument)
XmlExtensions Class See Also
Creates a view based on the specified XML document.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XDocument> AsLive(
    XDocument document
)
Visual Basic (Declaration)
Public Shared Function AsLive ( _
    document As XDocument _
) As View(Of XDocument)

Parameters

document
Type: System.Xml.Linq..::.XDocument
The XML document to expose as a view.

Return Value

A view representing the specified XML document.

Remarks

Since there can be only one root element in a document, the view based on a document (document.AsLive()) is similar to the view based on its root element (document.Root.AsLive()). The difference is that the document view contains the document as its only item, and the root view contains the root as its only item. This difference is essential only when the root of the document is replaced with a different element (and so the whole XML tree changes), then the document view remains valid and shows the changed document contents, whereas the root view becomes disconnected from the document.

Note: This view is owned by the XDocument object (it is stored as one of its annotations), so, if you create a view for the same document several times, it will be the same object.

See Also

XmlExtensions Class
AsLive Overload
C1.LiveLinq.LiveViews.Xml Namespace


AsLive Method (XElement)

[image]

.NET Framework Class Library
XmlExtensions..::.AsLive Method (XElement)
XmlExtensions Class See Also
Creates a view based on the specified XML element.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> AsLive(
    XElement element
)
Visual Basic (Declaration)
Public Shared Function AsLive ( _
    element As XElement _
) As View(Of XElement)

Parameters

element
Type: System.Xml.Linq..::.XElement
The XML element to expose as a view.

Return Value

A view representing the specified XML element.

Remarks

This view represents a single XML node. Therefore, as a collection of items, this view's Count is always 1. This view is usually used as a starting point to construct a view containing elements or attributes from this node's descendants by using a query with operators from XmlExtensions such as Elements, Descendants and others, in combination with standard LINQ query operators where, join and others.

Note: This view is owned by the XElement object (it is stored as one of its annotations), so, if you create a view for the same element several times, it will be the same object.

See Also

XmlExtensions Class
AsLive Overload
C1.LiveLinq.LiveViews.Xml Namespace


Attributes Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.Attributes Method
XmlExtensions Class See Also

Overload List

Name | Description
Attributes(View<(Of <(XElement>)>)) | Returns a view representing the collection of the attributes of every element in the source view.
Attributes(View<(Of <(XElement>)>), XName) | Returns a view representing a filtered collection of the attributes of every element in the source view. Only attributes that have a matching XName are included.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


Attributes Method (View(XElement))

[image]

.NET Framework Class Library
XmlExtensions..::.Attributes Method (View<(Of <(XElement>)>))
XmlExtensions Class See Also
Returns a view representing the collection of the attributes of every element in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XAttribute> Attributes(
    View<XElement> view
)
Visual Basic (Declaration)
Public Shared Function Attributes ( _
    view As View(Of XElement) _
) As View(Of XAttribute)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XElement >)>)
The source view.

Return Value

A view containing the attributes of every element in the source view.

See Also

XmlExtensions Class
Attributes Overload
C1.LiveLinq.LiveViews.Xml Namespace


Attributes Method (View(XElement), XName)

[image]

.NET Framework Class Library
XmlExtensions..::.Attributes Method (View<(Of <(XElement>)>), XName)
XmlExtensions Class See Also
Returns a view representing a filtered collection of the attributes of every element in the source view. Only attributes that have a matching XName are included.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XAttribute> Attributes(
    View<XElement> view,
    XName name
)
Visual Basic (Declaration)
Public Shared Function Attributes ( _
    view As View(Of XElement), _
    name As XName _
) As View(Of XAttribute)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XElement >)>)
The source view.
name
Type: System.Xml.Linq..::.XName
The XName to match.

Return Value

A view that contains a filtered collection of the attributes of every element in the source view. Only attributes that have a matching XName are included.

See Also

XmlExtensions Class
Attributes Overload
C1.LiveLinq.LiveViews.Xml Namespace


BeginUpdate Method

[image]

.NET Framework Class Library
XmlExtensions..::.BeginUpdate Method
XmlExtensions Class See Also
Suspends notifications while massive changes are being made to an XML node and its descendants.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static void BeginUpdate(
    XContainer node
)
Visual Basic (Declaration)
Public Shared Sub BeginUpdate ( _
    node As XContainer _
)

Parameters

node
Type: System.Xml.Linq..::.XContainer
The node that is the root of a tree where massive changes are made in code.

Remarks

This method must be followed by EndUpdate(XContainer).

Use this method when you already have indexes over this XML or live views based on it, and you need to perform massive changes on the contents of this node and its descendants. Without this method, every single change you make causes LiveLinq to perform necessary operations for maintaining your indexes and live views dependent on this node and its descendants. In case of massive changes, this can be slower than to wait until the massive changes are done and rebuild the indexes and live views.

Between BeginUpdate and EndUpdate(XContainer) calls, indexes, live views, bound controls and other change notification listeners are not updated, they don't receive change notifications. When EndUpdate(XContainer) is called, a SourceChangeType.Reset notification is sent, meaning all indexes, live views and other collections dependent on this node and its descendants must be rebuilt from scratch.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


DescendantNodes(T) Method

[image]

.NET Framework Class Library
XmlExtensions..::.DescendantNodes<(Of <(T>)>) Method
XmlExtensions Class See Also
Returns a view representing the collection of the descendent nodes of every element and document in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XNode> DescendantNodes<T>(
    View<T> view
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function DescendantNodes(Of T As XContainer) ( _
    view As View(Of T) _
) As View(Of XNode)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view containing every descendent node of every document and element in the source view.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


DescendantNodesAndSelf Method

[image]

.NET Framework Class Library
XmlExtensions..::.DescendantNodesAndSelf Method
XmlExtensions Class See Also
Returns a view representing the collection of nodes that contains every element in the source view, and the descendent nodes of every element in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XNode> DescendantNodesAndSelf(
    View<XElement> view
)
Visual Basic (Declaration)
Public Shared Function DescendantNodesAndSelf ( _
    view As View(Of XElement) _
) As View(Of XNode)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XElement >)>)
The source view.

Return Value

A view containing every element in the source view, and the descendent nodes of every element in the source view.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


Descendants Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.Descendants Method
XmlExtensions Class See Also

Overload List

Name | Description
Descendants<(Of <(T>)>)(View<(Of <(T>)>)) | Returns a view representing the collection of elements that contains the descendent elements of every element and document in the source view.
Descendants<(Of <(T>)>)(View<(Of <(T>)>), XName) | Returns a view representing a filtered collection of elements that contains the descendent elements of every element and document in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


Descendants(T) Method (View(T))

[image]

.NET Framework Class Library
XmlExtensions..::.Descendants<(Of <(T>)>) Method (View<(Of <(T>)>))
XmlExtensions Class See Also
Returns a view representing the collection of elements that contains the descendent elements of every element and document in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> Descendants<T>(
    View<T> view
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function Descendants(Of T As XContainer) ( _
    view As View(Of T) _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view containing every descendent element of every element and document in the source view.

See Also

XmlExtensions Class
Descendants Overload
C1.LiveLinq.LiveViews.Xml Namespace


Descendants(T) Method (View(T), XName)

[image]

.NET Framework Class Library
XmlExtensions..::.Descendants<(Of <(T>)>) Method (View<(Of <(T>)>), XName)
XmlExtensions Class See Also
Returns a view representing a filtered collection of elements that contains the descendent elements of every element and document in the source view. Only elements that have a matching XName are included.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> Descendants<T>(
    View<T> view,
    XName name
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function Descendants(Of T As XContainer) ( _
    view As View(Of T), _
    name As XName _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.
name
Type: System.Xml.Linq..::.XName
The XName to match.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view containing descendants of elements and documents in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
Descendants Overload
C1.LiveLinq.LiveViews.Xml Namespace


DescendantsAndSelf Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.DescendantsAndSelf Method
XmlExtensions Class See Also

Overload List

Name | Description
DescendantsAndSelf(View<(Of <(XElement>)>)) | Returns a view representing a collection of elements that contains every element in the source view, and the descendent elements of every element in the source view.
DescendantsAndSelf(View<(Of <(XElement>)>), XName) | Returns a view representing a filtered collection of elements that contains every element in the source view, and the descendants of every element in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


DescendantsAndSelf Method (View(XElement))

[image]

.NET Framework Class Library
XmlExtensions..::.DescendantsAndSelf Method (View<(Of <(XElement>)>))
XmlExtensions Class See Also
Returns a view representing a collection of elements that contains every element in the source view, and the descendent elements of every element in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> DescendantsAndSelf(
    View<XElement> view
)
Visual Basic (Declaration)
Public Shared Function DescendantsAndSelf ( _
    view As View(Of XElement) _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XElement >)>)
The source view.

Return Value

A view containing every element in the source view, and the descendent elements of every element in the source view.

See Also

XmlExtensions Class
DescendantsAndSelf Overload
C1.LiveLinq.LiveViews.Xml Namespace


DescendantsAndSelf Method (View(XElement), XName)

[image]

.NET Framework Class Library
XmlExtensions..::.DescendantsAndSelf Method (View<(Of <(XElement>)>), XName)
XmlExtensions Class See Also
Returns a view representing a filtered collection of elements that contains every element in the source view, and the descendants of every element in the source view. Only elements that have a matching XName are included.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> DescendantsAndSelf(
    View<XElement> view,
    XName name
)
Visual Basic (Declaration)
Public Shared Function DescendantsAndSelf ( _
    view As View(Of XElement), _
    name As XName _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XElement >)>)
The source view.
name
Type: System.Xml.Linq..::.XName
The XName to match.

Return Value

A view containing elements in the source view, and the descendants of elements in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
DescendantsAndSelf Overload
C1.LiveLinq.LiveViews.Xml Namespace


Elements Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.Elements Method
XmlExtensions Class See Also

Overload List

Name | Description
Elements<(Of <(T>)>)(View<(Of <(T>)>)) | Returns a view representing the collection of child elements of every element and document in the source view..
Elements<(Of <(T>)>)(View<(Of <(T>)>), XName) | Returns a view representing filtered collection of child elements of every element and document in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


Elements(T) Method (View(T))

[image]

.NET Framework Class Library
XmlExtensions..::.Elements<(Of <(T>)>) Method (View<(Of <(T>)>))
XmlExtensions Class See Also
Returns a view representing the collection of child elements of every element and document in the source view..

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> Elements<T>(
    View<T> view
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function Elements(Of T As XContainer) ( _
    view As View(Of T) _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view containing the child elements of every element and document in the source view.

See Also

XmlExtensions Class
Elements Overload
C1.LiveLinq.LiveViews.Xml Namespace


Elements(T) Method (View(T), XName)

[image]

.NET Framework Class Library
XmlExtensions..::.Elements<(Of <(T>)>) Method (View<(Of <(T>)>), XName)
XmlExtensions Class See Also
Returns a view representing filtered collection of child elements of every element and document in the source view. Only elements that have a matching XName are included.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> Elements<T>(
    View<T> view,
    XName name
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function Elements(Of T As XContainer) ( _
    view As View(Of T), _
    name As XName _
) As View(Of XElement)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.
name
Type: System.Xml.Linq..::.XName
The XName to match.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view that contains a filtered collection of child elements of every element and document in the source view. Only elements that have a matching XName are included.

See Also

XmlExtensions Class
Elements Overload
C1.LiveLinq.LiveViews.Xml Namespace


EndUpdate Method

[image]

.NET Framework Class Library
XmlExtensions..::.EndUpdate Method
XmlExtensions Class See Also
Ends notification suspension started with BeginUpdate(XContainer).

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static void EndUpdate(
    XContainer node
)
Visual Basic (Declaration)
Public Shared Sub EndUpdate ( _
    node As XContainer _
)

Parameters

node
Type: System.Xml.Linq..::.XContainer
The node that is the root of a tree where massive changes have been made since the BeginUpdate(XContainer) call.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


IndexedAttribute Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.IndexedAttribute Method
XmlExtensions Class See Also

Overload List

Name | Description
IndexedAttribute(XAttribute) | A hint to create and use an index on the specified XML attribute. The hint has default action.
IndexedAttribute(XAttribute, IndexingHintAction) | A hint to create and use an index on the specified XML attribute. The hint has specified action.
IndexedAttribute(XElement, XName) | A hint to create and use an index on the specified XML attribute. The hint has default action.
IndexedAttribute(XElement, XName, IndexingHintAction) | A hint to create and use an index on the specified XML attribute. The hint has specified action.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


IndexedAttribute Method (XAttribute)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedAttribute Method (XAttribute)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML attribute. The hint has default action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedAttribute(
    XAttribute attribute
)
Visual Basic (Declaration)
Public Shared Function IndexedAttribute ( _
    attribute As XAttribute _
) As XHint

Parameters

attribute
Type: System.Xml.Linq..::.XAttribute
The attribute to apply the hint to.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this attribute, if possible. After it is used for query optimization, before the query is executed, this hint is removed from the expression. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.Attribute("CustomerID").IndexedAttribute() == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedAttribute Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedAttribute Method (XAttribute, IndexingHintAction)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedAttribute Method (XAttribute, IndexingHintAction)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML attribute. The hint has specified action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedAttribute(
    XAttribute attribute,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedAttribute ( _
    attribute As XAttribute, _
    action As IndexingHintAction _
) As XHint

Parameters

attribute
Type: System.Xml.Linq..::.XAttribute
The attribute to apply the hint to.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this attribute, if possible. After it is used for query optimization, before the query is executed, this hint is removed from the expression. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.Attribute("CustomerID").IndexedAttribute(IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedAttribute Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedAttribute Method (XElement, XName)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedAttribute Method (XElement, XName)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML attribute. The hint has default action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedAttribute(
    XElement element,
    XName name
)
Visual Basic (Declaration)
Public Shared Function IndexedAttribute ( _
    element As XElement, _
    name As XName _
) As XHint

Parameters

element
Type: System.Xml.Linq..::.XElement
The element containing the attribute.
name
Type: System.Xml.Linq..::.XName
The name of the attribute to get.

Return Value

The attribute that has the specified name.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this attribute, if possible. When the query is executed, the hint method IndexedAttribute is replaced with the standard LINQ to XML method Attribute(XName). See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.IndexedAttribute("CustomerID") == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedAttribute Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedAttribute Method (XElement, XName, IndexingHintAction)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedAttribute Method (XElement, XName, IndexingHintAction)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML attribute. The hint has specified action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedAttribute(
    XElement element,
    XName name,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedAttribute ( _
    element As XElement, _
    name As XName, _
    action As IndexingHintAction _
) As XHint

Parameters

element
Type: System.Xml.Linq..::.XElement
The element containing the attribute.
name
Type: System.Xml.Linq..::.XName
The name of the attribute to get.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Return Value

The attribute that has the specified name.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this attribute, if possible. When the query is executed, the hint method IndexedAttribute is replaced with the standard LINQ to XML method Attribute(XName). See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.IndexedAttribute("CustomerID", IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedAttribute Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedElement Method

[image] [image]

.NET Framework Class Library
XmlExtensions..::.IndexedElement Method
XmlExtensions Class See Also

Overload List

Name | Description
IndexedElement(XElement) | A hint to create and use an index on the specified XML element. The hint has default action.
IndexedElement(XContainer, XName) | A hint to create and use an index on the specified XML element. The hint has default action.
IndexedElement(XElement, IndexingHintAction) | A hint to create and use an index on the specified XML element. The hint has specified action.
IndexedElement(XContainer, XName, IndexingHintAction) | A hint to create and use an index on the specified XML element. The hint has specified action.

See Also

XmlExtensions Class
XmlExtensions Members
C1.LiveLinq.LiveViews.Xml Namespace


IndexedElement Method (XElement)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedElement Method (XElement)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML element. The hint has default action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedElement(
    XElement element
)
Visual Basic (Declaration)
Public Shared Function IndexedElement ( _
    element As XElement _
) As XHint

Parameters

element
Type: System.Xml.Linq..::.XElement
The element to apply the hint to.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this element, if possible. After it is used for query optimization, before the query is executed, this hint is removed from the expression. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.Element("CustomerID").IndexedElement() == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedElement Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedElement Method (XContainer, XName)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedElement Method (XContainer, XName)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML element. The hint has default action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedElement(
    XContainer container,
    XName name
)
Visual Basic (Declaration)
Public Shared Function IndexedElement ( _
    container As XContainer, _
    name As XName _
) As XHint

Parameters

container
Type: System.Xml.Linq..::.XContainer
The element or document containing the element.
name
Type: System.Xml.Linq..::.XName
The name of the element to get.

Return Value

The element that has the specified name.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this element, if possible. When the query is executed, the hint method IndexedElement is replaced with the standard LINQ to XML method Element(XName). See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.IndexedElement("CustomerID") == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedElement Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedElement Method (XElement, IndexingHintAction)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedElement Method (XElement, IndexingHintAction)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML element. The hint has specified action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedElement(
    XElement element,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedElement ( _
    element As XElement, _
    action As IndexingHintAction _
) As XHint

Parameters

element
Type: System.Xml.Linq..::.XElement
The element to apply the hint to.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Return Value

Formally, the hint returns the same value that it receives in the parameter. In fact, it is never executed, its role is purely declarative.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this element, if possible. After it is used for query optimization, before the query is executed, this hint is removed from the expression. See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.Element("CustomerID").IndexedElement(IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedElement Overload
C1.LiveLinq.LiveViews.Xml Namespace


IndexedElement Method (XContainer, XName, IndexingHintAction)

[image]

.NET Framework Class Library
XmlExtensions..::.IndexedElement Method (XContainer, XName, IndexingHintAction)
XmlExtensions Class Example See Also
A hint to create and use an index on the specified XML element. The hint has specified action.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static XHint IndexedElement(
    XContainer container,
    XName name,
    IndexingHintAction action
)
Visual Basic (Declaration)
Public Shared Function IndexedElement ( _
    container As XContainer, _
    name As XName, _
    action As IndexingHintAction _
) As XHint

Parameters

container
Type: System.Xml.Linq..::.XContainer
The element or document containing the element.
name
Type: System.Xml.Linq..::.XName
The name of the element to get.
action
Type: C1.LiveLinq..::.IndexingHintAction
The action specified by the hint.

Return Value

The element that has the specified name.

Remarks

Hints are used declaratively. They tell LiveLinq query optimizer to create and use an index on this element, if possible. When the query is executed, the hint method IndexedElement is replaced with the standard LINQ to XML method Element(XName). See Hints for more details.

Examples

Copy CodeC#
var query =
    from c in customers
    where (string)c.IndexedElement("CustomerID", IndexingHintAction.Mandatory) == "ALFKI"
    select c;

See Also

XmlExtensions Class
IndexedElement Overload
C1.LiveLinq.LiveViews.Xml Namespace


Nodes(T) Method

[image]

.NET Framework Class Library
XmlExtensions..::.Nodes<(Of <(T>)>) Method
XmlExtensions Class See Also
Returns a view representing the collection of child nodes of every document and element in the source view.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XNode> Nodes<T>(
    View<T> view
)
where T : XContainer
Visual Basic (Declaration)
Public Shared Function Nodes(Of T As XContainer) ( _
    view As View(Of T) _
) As View(Of XNode)

Parameters

view
Type: C1.LiveLinq.LiveViews..::.View <(Of <(T>)>)
The source view.

Type Parameters

T
The type of the objects in the source view, constrained to XContainer.

Return Value

A view containing every child node of every document and element in the source view.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


Root Method

[image]

.NET Framework Class Library
XmlExtensions..::.Root Method
XmlExtensions Class See Also
Gets the view for the root element of the XML tree for this document.

Namespace: C1.LiveLinq.LiveViews.Xml
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<XElement> Root(
    View<XDocument> documentView
)
Visual Basic (Declaration)
Public Shared Function Root ( _
    documentView As View(Of XDocument) _
) As View(Of XElement)

Parameters

documentView
Type: C1.LiveLinq.LiveViews..::.View <(Of <( XDocument >)>)
The view representing this XML document.

Return Value

A view containing a single element, the root of the XML tree.

See Also

XmlExtensions Class
C1.LiveLinq.LiveViews.Xml Namespace


C1.WPF.LiveLinq Namespace

[image]

.NET Framework Class Library
C1.WPF.LiveLinq Namespace

Classes

Class | Description
WpfExtensions | Provides a set of static (extension) methods for INotifyCollectionChanged and ObservableCollection<(Of <(T>)>) types (specific to WPF).


WpfExtensions Class

[image]

.NET Framework Class Library
WpfExtensions Class
Members See Also
Provides a set of static (extension) methods for INotifyCollectionChanged and ObservableCollection<(Of <(T>)>) types (specific to WPF).

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static class WpfExtensions
Visual Basic (Declaration)
Public NotInheritable Class WpfExtensions

Inheritance Hierarchy

System..::.Object
C1.WPF.LiveLinq..::.WpfExtensions

See Also

WpfExtensions Members
C1.WPF.LiveLinq Namespace


WpfExtensions Members

[image] [image]

.NET Framework Class Library
WpfExtensions Members
WpfExtensions Class Methods See Also

Methods

Name | Description
AsLive | Overloaded.
ToIndexed | Overloaded.

See Also

WpfExtensions Class
C1.WPF.LiveLinq Namespace


WpfExtensions Methods

[image] [image]

.NET Framework Class Library
WpfExtensions Methods
WpfExtensions Class See Also

Methods

Name | Description
AsLive | Overloaded.
ToIndexed | Overloaded.

See Also

WpfExtensions Class
C1.WPF.LiveLinq Namespace


AsLive Method

[image] [image]

.NET Framework Class Library
WpfExtensions..::.AsLive Method
WpfExtensions Class See Also

Overload List

Name | Description
AsLive<(Of <(T>)>)(ObservableCollection<(Of <(T>)>)) | A typed specialization of the AsLive<(Of <(T>)>)(INotifyCollectionChanged) method.
AsLive<(Of <(T>)>)(INotifyCollectionChanged) | Creates a view based on the specified INotifyCollectionChanged data source.
AsLive<(Of <(T>)>)(ObservableCollection<(Of <(T>)>), ViewOrder) | A typed specialization of the AsLive<(Of <(T>)>)(INotifyCollectionChanged, ViewOrder) method.
AsLive<(Of <(T>)>)(INotifyCollectionChanged, ViewOrder) | Creates a view based on the specified INotifyCollectionChanged data source.

See Also

WpfExtensions Class
WpfExtensions Members
C1.WPF.LiveLinq Namespace


AsLive(T) Method (ObservableCollection(T))

[image]

.NET Framework Class Library
WpfExtensions..::.AsLive<(Of <(T>)>) Method (ObservableCollection<(Of <(T>)>))
WpfExtensions Class See Also
A typed specialization of the AsLive<(Of <(T>)>)(INotifyCollectionChanged) method.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    ObservableCollection<T> source
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As ObservableCollection(Of T) _
) As View(Of T)

Parameters

source
Type: System.Collections.ObjectModel..::.ObservableCollection <(Of <(T>)>)
The ObservableCollection<(Of <(T>)>) to expose as a view.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the ObservableCollection<(Of <(T>)>).

See Also

WpfExtensions Class
AsLive Overload
C1.WPF.LiveLinq Namespace


AsLive(T) Method (INotifyCollectionChanged)

[image]

.NET Framework Class Library
WpfExtensions..::.AsLive<(Of <(T>)>) Method (INotifyCollectionChanged)
WpfExtensions Class See Also
Creates a view based on the specified INotifyCollectionChanged data source.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    INotifyCollectionChanged source
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As INotifyCollectionChanged _
) As View(Of T)

Parameters

source
Type: System.Collections.Specialized..::.INotifyCollectionChanged
The INotifyCollectionChanged data source to expose as a view.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the INotifyCollectionChanged data source.

Remarks

Use this method to build views from existing data sources implementing INotifyCollectionChanged. The element type of this data source must implement INotifyPropertyChanged and, optionally, INotifyPropertyChanging, see Using the built-in collection class IndexedCollection(T) (LiveLinq to Objects).

The resulting view may have its elements ordered differently than they are ordered in the source. Correspondingly, views built on this resulting view (for example, if you filter it with Where) will not preserve the source order either. If you need to preserve the source order, consider using the other AsLive overload where you can specify to what extent you need the order to be preserved.

See Also

WpfExtensions Class
AsLive Overload
C1.WPF.LiveLinq Namespace


AsLive(T) Method (ObservableCollection(T), ViewOrder)

[image]

.NET Framework Class Library
WpfExtensions..::.AsLive<(Of <(T>)>) Method (ObservableCollection<(Of <(T>)>), ViewOrder)
WpfExtensions Class See Also
A typed specialization of the AsLive<(Of <(T>)>)(INotifyCollectionChanged, ViewOrder) method.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    ObservableCollection<T> source,
    ViewOrder order
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As ObservableCollection(Of T), _
    order As ViewOrder _
) As View(Of T)

Parameters

source
Type: System.Collections.ObjectModel..::.ObservableCollection <(Of <(T>)>)
The ObservableCollection<(Of <(T>)>) to expose as a view.
order
Type: C1.LiveLinq.LiveViews..::.ViewOrder
Specifies whether to preserve source item order.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the ObservableCollection<(Of <(T>)>).

See Also

WpfExtensions Class
AsLive Overload
C1.WPF.LiveLinq Namespace


AsLive(T) Method (INotifyCollectionChanged, ViewOrder)

[image]

.NET Framework Class Library
WpfExtensions..::.AsLive<(Of <(T>)>) Method (INotifyCollectionChanged, ViewOrder)
WpfExtensions Class See Also
Creates a view based on the specified INotifyCollectionChanged data source.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static View<T> AsLive<T>(
    INotifyCollectionChanged source,
    ViewOrder order
)
Visual Basic (Declaration)
Public Shared Function AsLive(Of T) ( _
    source As INotifyCollectionChanged, _
    order As ViewOrder _
) As View(Of T)

Parameters

source
Type: System.Collections.Specialized..::.INotifyCollectionChanged
The INotifyCollectionChanged data source to expose as a view.
order
Type: C1.LiveLinq.LiveViews..::.ViewOrder
Specifies whether to preserve source item order.

Type Parameters

T
The type of the elements in the view.

Return Value

A view that contains the same elements as the INotifyCollectionChanged data source.

Remarks

Use this method to build views from existing data sources implementing INotifyCollectionChanged. The element type of this data source must implement INotifyPropertyChanged and, optionally, INotifyPropertyChanging, see Using the built-in collection class IndexedCollection(T) (LiveLinq to Objects).

If the order parameter specifies preserving item order, the order of items in the source is preserved, at a certain performance cost, in the resulting view and in views based on it (for example, if you filter it with Where).

Note that Join does not preserve source order. If you need to order a join result, use OrderBy after Join.

See Also

WpfExtensions Class
AsLive Overload
C1.WPF.LiveLinq Namespace


ToIndexed Method

[image] [image]

.NET Framework Class Library
WpfExtensions..::.ToIndexed Method
WpfExtensions Class See Also

Overload List

Name | Description
ToIndexed<(Of <(T>)>)(ObservableCollection<(Of <(T>)>)) | A typed specialization of the ToIndexed<(Of <(T>)>)(INotifyCollectionChanged) method.
ToIndexed<(Of <(T>)>)(INotifyCollectionChanged) | Creates an IndexedCollection<(Of <(T>)>) based on the specified INotifyCollectionChanged data source.

See Also

WpfExtensions Class
WpfExtensions Members
C1.WPF.LiveLinq Namespace


ToIndexed(T) Method (ObservableCollection(T))

[image]

.NET Framework Class Library
WpfExtensions..::.ToIndexed<(Of <(T>)>) Method (ObservableCollection<(Of <(T>)>))
WpfExtensions Class See Also
A typed specialization of the ToIndexed<(Of <(T>)>)(INotifyCollectionChanged) method.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedCollection<T> ToIndexed<T>(
    ObservableCollection<T> source
)
Visual Basic (Declaration)
Public Shared Function ToIndexed(Of T) ( _
    source As ObservableCollection(Of T) _
) As IndexedCollection(Of T)

Parameters

source
Type: System.Collections.ObjectModel..::.ObservableCollection <(Of <(T>)>)
An ObservableCollection<(Of <(T>)>) represent as an IndexedCollection<(Of <(T>)>).

Type Parameters

T
The type of the elements in the collection.

Return Value

An IndexedCollection<(Of <(T>)>) that contains the same elements as the ObservableCollection<(Of <(T>)>) and enables indexing of that collection.

See Also

WpfExtensions Class
ToIndexed Overload
C1.WPF.LiveLinq Namespace


ToIndexed(T) Method (INotifyCollectionChanged)

[image]

.NET Framework Class Library
WpfExtensions..::.ToIndexed<(Of <(T>)>) Method (INotifyCollectionChanged)
WpfExtensions Class See Also
Creates an IndexedCollection<(Of <(T>)>) based on the specified INotifyCollectionChanged data source.

Namespace: C1.WPF.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
public static IndexedCollection<T> ToIndexed<T>(
    INotifyCollectionChanged source
)
Visual Basic (Declaration)
Public Shared Function ToIndexed(Of T) ( _
    source As INotifyCollectionChanged _
) As IndexedCollection(Of T)

Parameters

source
Type: System.Collections.Specialized..::.INotifyCollectionChanged
An INotifyCollectionChanged data source to represent as an IndexedCollection<(Of <(T>)>).

Type Parameters

T
The type of the elements in the collection.

Return Value

An IndexedCollection<(Of <(T>)>) that contains the same elements as the INotifyCollectionChanged and enables indexing of that data source.

Remarks

Use this method to index and query your existing data sources implementing INotifyCollectionChanged. The element type of this data source must implement INotifyPropertyChanged and, optionally, INotifyPropertyChanging, see Using the built-in collection class IndexedCollection(T) (LiveLinq to Objects).

The collection returned by this method also implements the INotifyCollectionChanged interface, because this method actually returns objects of an internal derived class that implements that interface.

Note: Indexes created on the resulting IndexedCollection<(Of <(T>)>) are owned by it and not by the original data source. Every ToIndexed() call creates a separate object that has its own separate indexes. Avoid calling ToIndexed() repeatedly for the same collection because it can increase the cost of maintaining indexes.

See Also

WpfExtensions Class
ToIndexed Overload
C1.WPF.LiveLinq Namespace


IObservableSource(T).Changed Event

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.Changed Event
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event EventHandler<SourceChangeEventArgs<T>> IObservableSource<T>.Changed
Visual Basic (Declaration)
Private Event Changed As EventHandler(Of SourceChangeEventArgs(Of T))
    Implements IObservableSource(Of T).Changed

Implements

IObservableSource<(Of <(T>)>)..::.Changed

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).Changing Event

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.Changing Event
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event EventHandler<SourceChangeEventArgs<T>> IObservableSource<T>.Changing
Visual Basic (Declaration)
Private Event Changing As EventHandler(Of SourceChangeEventArgs(Of T))
    Implements IObservableSource(Of T).Changing

Implements

IObservableSource<(Of <(T>)>)..::.Changing

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IBindingList.ListChanged Event

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.ListChanged Event
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event ListChangedEventHandler IBindingList.ListChanged
Visual Basic (Declaration)
Private Event ListChanged As ListChangedEventHandler Implements IBindingList.ListChanged

Implements

IBindingList..::.ListChanged

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


INotifyPropertyChanged.PropertyChanged Event

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.INotifyPropertyChanged..::.PropertyChanged Event
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
Visual Basic (Declaration)
Private Event PropertyChanged As PropertyChangedEventHandler
    Implements INotifyPropertyChanged.PropertyChanged

Implements

INotifyPropertyChanged..::.PropertyChanged

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.ListChanged Event

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.ListChanged Event
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event ListChangedEventHandler IBindingList.ListChanged
Visual Basic (Declaration)
Private Event ListChanged As ListChangedEventHandler Implements IBindingList.ListChanged

Implements

IBindingList..::.ListChanged

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


INotifyPropertyChanged.PropertyChanged Event

[image]

.NET Framework Class Library
ViewRowCollection..::.INotifyPropertyChanged..::.PropertyChanged Event
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
Visual Basic (Declaration)
Private Event PropertyChanged As PropertyChangedEventHandler
    Implements INotifyPropertyChanged.PropertyChanged

Implements

INotifyPropertyChanged..::.PropertyChanged

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).EnableItemOrdinals Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IObservableSource<T>.EnableItemOrdinals()
Visual Basic (Declaration)
Private Sub EnableItemOrdinals Implements IObservableSource(Of T).EnableItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals()()()

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).Add Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.Add Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.Add(
    TRow item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As TRow _
) Implements ICollection(Of T).Add

Parameters

item
Type: TRow

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).Clear Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.Clear Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements ICollection(Of T).Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).Contains Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.Contains Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<T>.Contains(
    TRow item
)
Visual Basic (Declaration)
Private Function Contains ( _
    item As TRow _
) As Boolean Implements ICollection(Of T).Contains

Parameters

item
Type: TRow

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).CopyTo Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.CopyTo Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.CopyTo(
    TRow[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As TRow(), _
    arrayIndex As Integer _
) Implements ICollection(Of T).CopyTo

Parameters

array
Type: array< TRow >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).Remove Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.Remove Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<T>.Remove(
    TRow item
)
Visual Basic (Declaration)
Private Function Remove ( _
    item As TRow _
) As Boolean Implements ICollection(Of T).Remove

Parameters

item
Type: TRow

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IList(T).IndexOf Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IList<(Of <(T>)>)..::.IndexOf Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList<T>.IndexOf(
    TRow item
)
Visual Basic (Declaration)
Private Function IndexOf ( _
    item As TRow _
) As Integer Implements IList(Of T).IndexOf

Parameters

item
Type: TRow

Implements

IList<(Of <(T>)>)..::.IndexOf(T)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IList(T).Insert Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IList<(Of <(T>)>)..::.Insert Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<T>.Insert(
    int index,
    TRow item
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    item As TRow _
) Implements IList(Of T).Insert

Parameters

index
Type: System..::.Int32
item
Type: TRow

Implements

IList<(Of <(T>)>)..::.Insert(Int32, T)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IList(T).RemoveAt Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IList<(Of <(T>)>)..::.RemoveAt Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<T>.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList(Of T).RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.RemoveAt(Int32)

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IEnumerable..::.GetEnumerator Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IListSource.GetList Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IListSource..::.GetList Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IList IListSource.GetList()
Visual Basic (Declaration)
Private Function GetList As IList
    Implements IListSource.GetList

Implements

IListSource..::.GetList()()()

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ITypedList.GetItemProperties Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ITypedList..::.GetItemProperties Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptorCollection ITypedList.GetItemProperties(
    PropertyDescriptor[] listAccessors
)
Visual Basic (Declaration)
Private Function GetItemProperties ( _
    listAccessors As PropertyDescriptor() _
) As PropertyDescriptorCollection Implements ITypedList.GetItemProperties

Parameters

listAccessors
Type: array< System.ComponentModel..::.PropertyDescriptor >[]()[]

Implements

ITypedList..::.GetItemProperties(array<PropertyDescriptor>[]()[])

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ITypedList.GetListName Method

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ITypedList..::.GetListName Method
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
string ITypedList.GetListName(
    PropertyDescriptor[] listAccessors
)
Visual Basic (Declaration)
Private Function GetListName ( _
    listAccessors As PropertyDescriptor() _
) As String Implements ITypedList.GetListName

Parameters

listAccessors
Type: array< System.ComponentModel..::.PropertyDescriptor >[]()[]

Implements

ITypedList..::.GetListName(array<PropertyDescriptor>[]()[])

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).EnableItemOrdinals Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IObservableSource<T>.EnableItemOrdinals()
Visual Basic (Declaration)
Private Sub EnableItemOrdinals Implements IObservableSource(Of T).EnableItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals()()()

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.AddIndex Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.AddIndex Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.AddIndex(
    PropertyDescriptor property
)
Visual Basic (Declaration)
Private Sub AddIndex ( _
    property As PropertyDescriptor _
) Implements IBindingList.AddIndex

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor

Implements

IBindingList..::.AddIndex(PropertyDescriptor)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.AddNew Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.AddNew Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object IBindingList.AddNew()
Visual Basic (Declaration)
Private Function AddNew As Object Implements IBindingList.AddNew

Implements

IBindingList..::.AddNew()()()

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.ApplySort Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.ApplySort Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.ApplySort(
    PropertyDescriptor property,
    ListSortDirection direction
)
Visual Basic (Declaration)
Private Sub ApplySort ( _
    property As PropertyDescriptor, _
    direction As ListSortDirection _
) Implements IBindingList.ApplySort

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor
direction
Type: System.ComponentModel..::.ListSortDirection

Implements

IBindingList..::.ApplySort(PropertyDescriptor, ListSortDirection)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.Find Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.Find Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IBindingList.Find(
    PropertyDescriptor property,
    Object key
)
Visual Basic (Declaration)
Private Function Find ( _
    property As PropertyDescriptor, _
    key As Object _
) As Integer Implements IBindingList.Find

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor
key
Type: System..::.Object

Implements

IBindingList..::.Find(PropertyDescriptor, Object)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.RemoveIndex Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.RemoveIndex Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.RemoveIndex(
    PropertyDescriptor property
)
Visual Basic (Declaration)
Private Sub RemoveIndex ( _
    property As PropertyDescriptor _
) Implements IBindingList.RemoveIndex

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor

Implements

IBindingList..::.RemoveIndex(PropertyDescriptor)

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.RemoveSort Method

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.RemoveSort Method
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.RemoveSort()
Visual Basic (Declaration)
Private Sub RemoveSort Implements IBindingList.RemoveSort

Implements

IBindingList..::.RemoveSort()()()

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IIndexScanner(T).All Method

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.IIndexScanner<(Of <(T>)>)..::.All Method
Index<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexQuery<T> IIndexScanner<T>.All(
    Order order
)
Visual Basic (Declaration)
Private Function All ( _
    order As Order _
) As IndexQuery(Of T) Implements IIndexScanner(Of T).All

Parameters

order
Type: C1.LiveLinq..::.Order

Implements

IIndexScanner<(Of <(T>)>)..::.All(Order)

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(KeyValuePair(LambdaExpression, Index(T))).Add Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.Add Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<KeyValuePair<LambdaExpression, Index<T>>>.Add(
    KeyValuePair<LambdaExpression, Index<T>> item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As KeyValuePair(Of LambdaExpression, Index(Of T)) _
) Implements ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))).Add

Parameters

item
Type: System.Collections.Generic..::.KeyValuePair <(Of <( LambdaExpression, Index <(Of <( T >)>)>)>)

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).Clear Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.Clear Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<IIndexScanner<T>>.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements ICollection(Of IIndexScanner(Of T)).Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(KeyValuePair(LambdaExpression, Index(T))).Contains Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.Contains Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<KeyValuePair<LambdaExpression, Index<T>>>.Contains(
    KeyValuePair<LambdaExpression, Index<T>> item
)
Visual Basic (Declaration)
Private Function Contains ( _
    item As KeyValuePair(Of LambdaExpression, Index(Of T)) _
) As Boolean Implements ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))).Contains

Parameters

item
Type: System.Collections.Generic..::.KeyValuePair <(Of <( LambdaExpression, Index <(Of <( T >)>)>)>)

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(KeyValuePair(LambdaExpression, Index(T))).CopyTo Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.CopyTo Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<KeyValuePair<LambdaExpression, Index<T>>>.CopyTo(
    KeyValuePair<LambdaExpression, Index<T>>[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As KeyValuePair(Of LambdaExpression, Index(Of T))(), _
    arrayIndex As Integer _
) Implements ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))).CopyTo

Parameters

array
Type: array< System.Collections.Generic..::.KeyValuePair <(Of <( LambdaExpression, Index <(Of <( T >)>)>)>) >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).Remove Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.Remove Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<IIndexScanner<T>>.Remove(
    IIndexScanner<T> scanner
)
Visual Basic (Declaration)
Private Function Remove ( _
    scanner As IIndexScanner(Of T) _
) As Boolean Implements ICollection(Of IIndexScanner(Of T)).Remove

Parameters

scanner
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(KeyValuePair(LambdaExpression, Index(T))).Remove Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.Remove Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<KeyValuePair<LambdaExpression, Index<T>>>.Remove(
    KeyValuePair<LambdaExpression, Index<T>> item
)
Visual Basic (Declaration)
Private Function Remove ( _
    item As KeyValuePair(Of LambdaExpression, Index(Of T)) _
) As Boolean Implements ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))).Remove

Parameters

item
Type: System.Collections.Generic..::.KeyValuePair <(Of <( LambdaExpression, Index <(Of <( T >)>)>)>)

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).Add Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.Add Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IDictionary<LambdaExpression, Index<T>>.Add(
    LambdaExpression keySelector,
    Index<T> index
)
Visual Basic (Declaration)
Private Sub Add ( _
    keySelector As LambdaExpression, _
    index As Index(Of T) _
) Implements IDictionary(Of LambdaExpression, Index(Of T)).Add

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
index
Type: C1.LiveLinq.Indexing..::.Index <(Of <( T >)>)

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.Add(TKey, TValue)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).ContainsKey Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.ContainsKey Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IDictionary<LambdaExpression, Index<T>>.ContainsKey(
    LambdaExpression key
)
Visual Basic (Declaration)
Private Function ContainsKey ( _
    key As LambdaExpression _
) As Boolean Implements IDictionary(Of LambdaExpression, Index(Of T)).ContainsKey

Parameters

key
Type: System.Linq.Expressions..::.LambdaExpression

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.ContainsKey(TKey)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).TryGetValue Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.TryGetValue Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IDictionary<LambdaExpression, Index<T>>.TryGetValue(
    LambdaExpression keySelector,
    out Index<T> index
)
Visual Basic (Declaration)
Private Function TryGetValue ( _
    keySelector As LambdaExpression, _
    <OutAttribute> ByRef index As Index(Of T) _
) As Boolean Implements IDictionary(Of LambdaExpression, Index(Of T)).TryGetValue

Parameters

keySelector
Type: System.Linq.Expressions..::.LambdaExpression
index
Type: C1.LiveLinq.Indexing..::.Index <(Of <( T >)>) %

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.TryGetValue(TKey, TValue%)

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IEnumerable(KeyValuePair(LambdaExpression, Index(T))).GetEnumerator Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IEnumerable<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.GetEnumerator Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator<KeyValuePair<LambdaExpression, Index<T>>> IEnumerable<KeyValuePair<LambdaExpression, Index<T>>>.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator(Of KeyValuePair(Of LambdaExpression, Index(Of T)))
    Implements IEnumerable(Of KeyValuePair(Of LambdaExpression, Index(Of T))).GetEnumerator

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).Add Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.Add Method
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<IIndexScanner<T>>.Add(
    IIndexScanner<T> item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As IIndexScanner(Of T) _
) Implements ICollection(Of IIndexScanner(Of T)).Add

Parameters

item
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).Contains Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.Contains Method
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<IIndexScanner<T>>.Contains(
    IIndexScanner<T> item
)
Visual Basic (Declaration)
Private Function Contains ( _
    item As IIndexScanner(Of T) _
) As Boolean Implements ICollection(Of IIndexScanner(Of T)).Contains

Parameters

item
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).CopyTo Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.CopyTo Method
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<IIndexScanner<T>>.CopyTo(
    IIndexScanner<T>[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As IIndexScanner(Of T)(), _
    arrayIndex As Integer _
) Implements ICollection(Of IIndexScanner(Of T)).CopyTo

Parameters

array
Type: array< C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <( T >)>) >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).Remove Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.Remove Method
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<IIndexScanner<T>>.Remove(
    IIndexScanner<T> item
)
Visual Basic (Declaration)
Private Function Remove ( _
    item As IIndexScanner(Of T) _
) As Boolean Implements ICollection(Of IIndexScanner(Of T)).Remove

Parameters

item
Type: C1.LiveLinq.Indexing.Search..::.IIndexScanner <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
GroupingQuery<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
GroupingQuery<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

GroupingQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
GroupingQuery<(Of <(TKey, T>)>)..::.IEnumerable..::.GetEnumerator Method
GroupingQuery<(Of <(TKey, T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

GroupingQuery<(Of <(TKey, T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
IndexQuery<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
IndexQuery<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing.Search
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

IndexQuery<(Of <(T>)>) Class
C1.LiveLinq.Indexing.Search Namespace


ICollection(Subindex(T)).Add Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.ICollection<(Of <(Subindex<(Of <(T>)>)>)>)..::.Add Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<Subindex<T>>.Add(
    Subindex<T> item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As Subindex(Of T) _
) Implements ICollection(Of Subindex(Of T)).Add

Parameters

item
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(Subindex(T)).Contains Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.ICollection<(Of <(Subindex<(Of <(T>)>)>)>)..::.Contains Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<Subindex<T>>.Contains(
    Subindex<T> index
)
Visual Basic (Declaration)
Private Function Contains ( _
    index As Subindex(Of T) _
) As Boolean Implements ICollection(Of Subindex(Of T)).Contains

Parameters

index
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)

Implements

ICollection<(Of <(T>)>)..::.Contains(T)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(Subindex(T)).CopyTo Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.ICollection<(Of <(Subindex<(Of <(T>)>)>)>)..::.CopyTo Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<Subindex<T>>.CopyTo(
    Subindex<T>[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As Subindex(Of T)(), _
    arrayIndex As Integer _
) Implements ICollection(Of Subindex(Of T)).CopyTo

Parameters

array
Type: array< C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>) >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IList(Subindex(T)).IndexOf Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.IList<(Of <(Subindex<(Of <(T>)>)>)>)..::.IndexOf Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList<Subindex<T>>.IndexOf(
    Subindex<T> index
)
Visual Basic (Declaration)
Private Function IndexOf ( _
    index As Subindex(Of T) _
) As Integer Implements IList(Of Subindex(Of T)).IndexOf

Parameters

index
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)

Implements

IList<(Of <(T>)>)..::.IndexOf(T)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IList(Subindex(T)).Insert Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.IList<(Of <(Subindex<(Of <(T>)>)>)>)..::.Insert Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<Subindex<T>>.Insert(
    int index,
    Subindex<T> item
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    item As Subindex(Of T) _
) Implements IList(Of Subindex(Of T)).Insert

Parameters

index
Type: System..::.Int32
item
Type: C1.LiveLinq.Indexing..::.Subindex <(Of <( T >)>)

Implements

IList<(Of <(T>)>)..::.Insert(Int32, T)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IList(Subindex(T)).RemoveAt Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.IList<(Of <(Subindex<(Of <(T>)>)>)>)..::.RemoveAt Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<Subindex<T>>.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList(Of Subindex(Of T)).RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.RemoveAt(Int32)

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection.CopyTo Method

[image]

.NET Framework Class Library
View..::.ICollection..::.CopyTo Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection.CopyTo(
    Array array,
    int index
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As Array, _
    index As Integer _
) Implements ICollection.CopyTo

Parameters

array
Type: System..::.Array
index
Type: System..::.Int32

Implements

ICollection..::.CopyTo(Array, Int32)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
View..::.IEnumerable..::.GetEnumerator Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Add Method

[image]

.NET Framework Class Library
View..::.IList..::.Add Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList.Add(
    Object value
)
Visual Basic (Declaration)
Private Function Add ( _
    value As Object _
) As Integer Implements IList.Add

Parameters

value
Type: System..::.Object

Implements

IList..::.Add(Object)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Clear Method

[image]

.NET Framework Class Library
View..::.IList..::.Clear Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements IList.Clear

Implements

IList..::.Clear()()()

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Contains Method

[image]

.NET Framework Class Library
View..::.IList..::.Contains Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IList.Contains(
    Object value
)
Visual Basic (Declaration)
Private Function Contains ( _
    value As Object _
) As Boolean Implements IList.Contains

Parameters

value
Type: System..::.Object

Implements

IList..::.Contains(Object)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.IndexOf Method

[image]

.NET Framework Class Library
View..::.IList..::.IndexOf Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList.IndexOf(
    Object value
)
Visual Basic (Declaration)
Private Function IndexOf ( _
    value As Object _
) As Integer Implements IList.IndexOf

Parameters

value
Type: System..::.Object

Implements

IList..::.IndexOf(Object)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Insert Method

[image]

.NET Framework Class Library
View..::.IList..::.Insert Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Insert(
    int index,
    Object value
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    value As Object _
) Implements IList.Insert

Parameters

index
Type: System..::.Int32
value
Type: System..::.Object

Implements

IList..::.Insert(Int32, Object)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Remove Method

[image]

.NET Framework Class Library
View..::.IList..::.Remove Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Remove(
    Object value
)
Visual Basic (Declaration)
Private Sub Remove ( _
    value As Object _
) Implements IList.Remove

Parameters

value
Type: System..::.Object

Implements

IList..::.Remove(Object)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.RemoveAt Method

[image]

.NET Framework Class Library
View..::.IList..::.RemoveAt Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList.RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList..::.RemoveAt(Int32)

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IListSource.GetList Method

[image]

.NET Framework Class Library
View..::.IListSource..::.GetList Method
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IList IListSource.GetList()
Visual Basic (Declaration)
Private Function GetList As IList
    Implements IListSource.GetList

Implements

IListSource..::.GetList()()()

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).EnableItemOrdinals Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IObservableSource<T>.EnableItemOrdinals()
Visual Basic (Declaration)
Private Sub EnableItemOrdinals Implements IObservableSource(Of T).EnableItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals()()()

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ICollection(T).Add Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.ICollection<(Of <(T>)>)..::.Add Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.Add(
    T item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As T _
) Implements ICollection(Of T).Add

Parameters

item
Type: T

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ICollection(T).Clear Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.ICollection<(Of <(T>)>)..::.Clear Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements ICollection(Of T).Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ICollection(T).CopyTo Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.ICollection<(Of <(T>)>)..::.CopyTo Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<T>.CopyTo(
    T[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As T(), _
    arrayIndex As Integer _
) Implements ICollection(Of T).CopyTo

Parameters

array
Type: array< T >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ICollection(T).Remove Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.ICollection<(Of <(T>)>)..::.Remove Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<T>.Remove(
    T item
)
Visual Basic (Declaration)
Private Function Remove ( _
    item As T _
) As Boolean Implements ICollection(Of T).Remove

Parameters

item
Type: T

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IList(T).Insert Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IList<(Of <(T>)>)..::.Insert Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<T>.Insert(
    int index,
    T item
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    item As T _
) Implements IList(Of T).Insert

Parameters

index
Type: System..::.Int32
item
Type: T

Implements

IList<(Of <(T>)>)..::.Insert(Int32, T)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IList(T).RemoveAt Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IList<(Of <(T>)>)..::.RemoveAt Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<T>.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList(Of T).RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.RemoveAt(Int32)

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IDisposable.Dispose Method

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IDisposable..::.Dispose Method
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IDisposable.Dispose()
Visual Basic (Declaration)
Private Sub Dispose Implements IDisposable.Dispose

Implements

IDisposable..::.Dispose()()()

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetAttributes Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetAttributes Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
AttributeCollection ICustomTypeDescriptor.GetAttributes()
Visual Basic (Declaration)
Private Function GetAttributes As AttributeCollection
    Implements ICustomTypeDescriptor.GetAttributes

Implements

ICustomTypeDescriptor..::.GetAttributes()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetClassName Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetClassName Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
string ICustomTypeDescriptor.GetClassName()
Visual Basic (Declaration)
Private Function GetClassName As String
    Implements ICustomTypeDescriptor.GetClassName

Implements

ICustomTypeDescriptor..::.GetClassName()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetComponentName Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetComponentName Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
string ICustomTypeDescriptor.GetComponentName()
Visual Basic (Declaration)
Private Function GetComponentName As String
    Implements ICustomTypeDescriptor.GetComponentName

Implements

ICustomTypeDescriptor..::.GetComponentName()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetConverter Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetConverter Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
TypeConverter ICustomTypeDescriptor.GetConverter()
Visual Basic (Declaration)
Private Function GetConverter As TypeConverter
    Implements ICustomTypeDescriptor.GetConverter

Implements

ICustomTypeDescriptor..::.GetConverter()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetDefaultEvent Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetDefaultEvent Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
Visual Basic (Declaration)
Private Function GetDefaultEvent As EventDescriptor
    Implements ICustomTypeDescriptor.GetDefaultEvent

Implements

ICustomTypeDescriptor..::.GetDefaultEvent()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetDefaultProperty Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetDefaultProperty Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
Visual Basic (Declaration)
Private Function GetDefaultProperty As PropertyDescriptor
    Implements ICustomTypeDescriptor.GetDefaultProperty

Implements

ICustomTypeDescriptor..::.GetDefaultProperty()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetEditor Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetEditor Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object ICustomTypeDescriptor.GetEditor(
    Type editorBaseType
)
Visual Basic (Declaration)
Private Function GetEditor ( _
    editorBaseType As Type _
) As Object Implements ICustomTypeDescriptor.GetEditor

Parameters

editorBaseType
Type: System..::.Type

Implements

ICustomTypeDescriptor..::.GetEditor(Type)

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetEvents Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetEvents Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
Visual Basic (Declaration)
Private Function GetEvents As EventDescriptorCollection
    Implements ICustomTypeDescriptor.GetEvents

Implements

ICustomTypeDescriptor..::.GetEvents()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetEvents Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetEvents Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(
    Attribute[] attributes
)
Visual Basic (Declaration)
Private Function GetEvents ( _
    attributes As Attribute() _
) As EventDescriptorCollection Implements ICustomTypeDescriptor.GetEvents

Parameters

attributes
Type: array< System..::.Attribute >[]()[]

Implements

ICustomTypeDescriptor..::.GetEvents(array<Attribute>[]()[])

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetProperties Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetProperties Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
Visual Basic (Declaration)
Private Function GetProperties As PropertyDescriptorCollection
    Implements ICustomTypeDescriptor.GetProperties

Implements

ICustomTypeDescriptor..::.GetProperties()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetProperties Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetProperties Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(
    Attribute[] attributes
)
Visual Basic (Declaration)
Private Function GetProperties ( _
    attributes As Attribute() _
) As PropertyDescriptorCollection Implements ICustomTypeDescriptor.GetProperties

Parameters

attributes
Type: array< System..::.Attribute >[]()[]

Implements

ICustomTypeDescriptor..::.GetProperties(array<Attribute>[]()[])

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


ICustomTypeDescriptor.GetPropertyOwner Method

[image]

.NET Framework Class Library
ViewRow..::.ICustomTypeDescriptor..::.GetPropertyOwner Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object ICustomTypeDescriptor.GetPropertyOwner(
    PropertyDescriptor pd
)
Visual Basic (Declaration)
Private Function GetPropertyOwner ( _
    pd As PropertyDescriptor _
) As Object Implements ICustomTypeDescriptor.GetPropertyOwner

Parameters

pd
Type: System.ComponentModel..::.PropertyDescriptor

Implements

ICustomTypeDescriptor..::.GetPropertyOwner(PropertyDescriptor)

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


IEditableObject.BeginEdit Method

[image]

.NET Framework Class Library
ViewRow..::.IEditableObject..::.BeginEdit Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IEditableObject.BeginEdit()
Visual Basic (Declaration)
Private Sub BeginEdit Implements IEditableObject.BeginEdit

Implements

IEditableObject..::.BeginEdit()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


IEditableObject.CancelEdit Method

[image]

.NET Framework Class Library
ViewRow..::.IEditableObject..::.CancelEdit Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IEditableObject.CancelEdit()
Visual Basic (Declaration)
Private Sub CancelEdit Implements IEditableObject.CancelEdit

Implements

IEditableObject..::.CancelEdit()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


IEditableObject.EndEdit Method

[image]

.NET Framework Class Library
ViewRow..::.IEditableObject..::.EndEdit Method
ViewRow Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IEditableObject.EndEdit()
Visual Basic (Declaration)
Private Sub EndEdit Implements IEditableObject.EndEdit

Implements

IEditableObject..::.EndEdit()()()

See Also

ViewRow Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(ViewRow).EnableItemOrdinals Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IObservableSource<(Of <(ViewRow>)>)..::.EnableItemOrdinals Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IObservableSource<ViewRow>.EnableItemOrdinals()
Visual Basic (Declaration)
Private Sub EnableItemOrdinals Implements IObservableSource(Of ViewRow).EnableItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.EnableItemOrdinals()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection(ViewRow).Add Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection<(Of <(ViewRow>)>)..::.Add Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<ViewRow>.Add(
    ViewRow item
)
Visual Basic (Declaration)
Private Sub Add ( _
    item As ViewRow _
) Implements ICollection(Of ViewRow).Add

Parameters

item
Type: C1.LiveLinq.LiveViews..::.ViewRow

Implements

ICollection<(Of <(T>)>)..::.Add(T)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection(ViewRow).Clear Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection<(Of <(ViewRow>)>)..::.Clear Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<ViewRow>.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements ICollection(Of ViewRow).Clear

Implements

ICollection<(Of <(T>)>)..::.Clear()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection(ViewRow).CopyTo Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection<(Of <(ViewRow>)>)..::.CopyTo Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection<ViewRow>.CopyTo(
    ViewRow[] array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As ViewRow(), _
    arrayIndex As Integer _
) Implements ICollection(Of ViewRow).CopyTo

Parameters

array
Type: array< C1.LiveLinq.LiveViews..::.ViewRow >[]()[]
arrayIndex
Type: System..::.Int32

Implements

ICollection<(Of <(T>)>)..::.CopyTo(array<T>[]()[], Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection(ViewRow).Remove Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection<(Of <(ViewRow>)>)..::.Remove Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<ViewRow>.Remove(
    ViewRow row
)
Visual Basic (Declaration)
Private Function Remove ( _
    row As ViewRow _
) As Boolean Implements ICollection(Of ViewRow).Remove

Parameters

row
Type: C1.LiveLinq.LiveViews..::.ViewRow

Implements

ICollection<(Of <(T>)>)..::.Remove(T)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IEnumerable(ViewRow).GetEnumerator Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IEnumerable<(Of <(ViewRow>)>)..::.GetEnumerator Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator<ViewRow> IEnumerable<ViewRow>.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator(Of ViewRow)
    Implements IEnumerable(Of ViewRow).GetEnumerator

Implements

IEnumerable<(Of <(T>)>)..::.GetEnumerator()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList(ViewRow).Insert Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList<(Of <(ViewRow>)>)..::.Insert Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<ViewRow>.Insert(
    int index,
    ViewRow item
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    item As ViewRow _
) Implements IList(Of ViewRow).Insert

Parameters

index
Type: System..::.Int32
item
Type: C1.LiveLinq.LiveViews..::.ViewRow

Implements

IList<(Of <(T>)>)..::.Insert(Int32, T)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList(ViewRow).RemoveAt Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList<(Of <(ViewRow>)>)..::.RemoveAt Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList<ViewRow>.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList(Of ViewRow).RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.RemoveAt(Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection.CopyTo Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection..::.CopyTo Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICollection.CopyTo(
    Array array,
    int arrayIndex
)
Visual Basic (Declaration)
Private Sub CopyTo ( _
    array As Array, _
    arrayIndex As Integer _
) Implements ICollection.CopyTo

Parameters

array
Type: System..::.Array
arrayIndex
Type: System..::.Int32

Implements

ICollection..::.CopyTo(Array, Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Add Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Add Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList.Add(
    Object value
)
Visual Basic (Declaration)
Private Function Add ( _
    value As Object _
) As Integer Implements IList.Add

Parameters

value
Type: System..::.Object

Implements

IList..::.Add(Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Clear Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Clear Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Clear()
Visual Basic (Declaration)
Private Sub Clear Implements IList.Clear

Implements

IList..::.Clear()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Contains Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Contains Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IList.Contains(
    Object value
)
Visual Basic (Declaration)
Private Function Contains ( _
    value As Object _
) As Boolean Implements IList.Contains

Parameters

value
Type: System..::.Object

Implements

IList..::.Contains(Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.IndexOf Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.IndexOf Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IList.IndexOf(
    Object value
)
Visual Basic (Declaration)
Private Function IndexOf ( _
    value As Object _
) As Integer Implements IList.IndexOf

Parameters

value
Type: System..::.Object

Implements

IList..::.IndexOf(Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Insert Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Insert Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Insert(
    int index,
    Object value
)
Visual Basic (Declaration)
Private Sub Insert ( _
    index As Integer, _
    value As Object _
) Implements IList.Insert

Parameters

index
Type: System..::.Int32
value
Type: System..::.Object

Implements

IList..::.Insert(Int32, Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Remove Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Remove Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.Remove(
    Object row
)
Visual Basic (Declaration)
Private Sub Remove ( _
    row As Object _
) Implements IList.Remove

Parameters

row
Type: System..::.Object

Implements

IList..::.Remove(Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.RemoveAt Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.RemoveAt Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IList.RemoveAt(
    int index
)
Visual Basic (Declaration)
Private Sub RemoveAt ( _
    index As Integer _
) Implements IList.RemoveAt

Parameters

index
Type: System..::.Int32

Implements

IList..::.RemoveAt(Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.AddIndex Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.AddIndex Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.AddIndex(
    PropertyDescriptor property
)
Visual Basic (Declaration)
Private Sub AddIndex ( _
    property As PropertyDescriptor _
) Implements IBindingList.AddIndex

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor

Implements

IBindingList..::.AddIndex(PropertyDescriptor)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.AddNew Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.AddNew Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object IBindingList.AddNew()
Visual Basic (Declaration)
Private Function AddNew As Object Implements IBindingList.AddNew

Implements

IBindingList..::.AddNew()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.ApplySort Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.ApplySort Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.ApplySort(
    PropertyDescriptor property,
    ListSortDirection direction
)
Visual Basic (Declaration)
Private Sub ApplySort ( _
    property As PropertyDescriptor, _
    direction As ListSortDirection _
) Implements IBindingList.ApplySort

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor
direction
Type: System.ComponentModel..::.ListSortDirection

Implements

IBindingList..::.ApplySort(PropertyDescriptor, ListSortDirection)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.Find Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.Find Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
int IBindingList.Find(
    PropertyDescriptor property,
    Object key
)
Visual Basic (Declaration)
Private Function Find ( _
    property As PropertyDescriptor, _
    key As Object _
) As Integer Implements IBindingList.Find

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor
key
Type: System..::.Object

Implements

IBindingList..::.Find(PropertyDescriptor, Object)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.RemoveIndex Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.RemoveIndex Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.RemoveIndex(
    PropertyDescriptor property
)
Visual Basic (Declaration)
Private Sub RemoveIndex ( _
    property As PropertyDescriptor _
) Implements IBindingList.RemoveIndex

Parameters

property
Type: System.ComponentModel..::.PropertyDescriptor

Implements

IBindingList..::.RemoveIndex(PropertyDescriptor)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.RemoveSort Method

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.RemoveSort Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void IBindingList.RemoveSort()
Visual Basic (Declaration)
Private Sub RemoveSort Implements IBindingList.RemoveSort

Implements

IBindingList..::.RemoveSort()()()

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICancelAddNew.CancelNew Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICancelAddNew..::.CancelNew Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICancelAddNew.CancelNew(
    int itemIndex
)
Visual Basic (Declaration)
Private Sub CancelNew ( _
    itemIndex As Integer _
) Implements ICancelAddNew.CancelNew

Parameters

itemIndex
Type: System..::.Int32

Implements

ICancelAddNew..::.CancelNew(Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICancelAddNew.EndNew Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ICancelAddNew..::.EndNew Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
void ICancelAddNew.EndNew(
    int itemIndex
)
Visual Basic (Declaration)
Private Sub EndNew ( _
    itemIndex As Integer _
) Implements ICancelAddNew.EndNew

Parameters

itemIndex
Type: System..::.Int32

Implements

ICancelAddNew..::.EndNew(Int32)

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ITypedList.GetListName Method

[image]

.NET Framework Class Library
ViewRowCollection..::.ITypedList..::.GetListName Method
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
string ITypedList.GetListName(
    PropertyDescriptor[] listAccessors
)
Visual Basic (Declaration)
Private Function GetListName ( _
    listAccessors As PropertyDescriptor() _
) As String Implements ITypedList.GetListName

Parameters

listAccessors
Type: array< System.ComponentModel..::.PropertyDescriptor >[]()[]

Implements

ITypedList..::.GetListName(array<PropertyDescriptor>[]()[])

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IEnumerable.GetEnumerator Method

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>)..::.IEnumerable..::.GetEnumerator Method
Ordering<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IEnumerator IEnumerable.GetEnumerator()
Visual Basic (Declaration)
Private Function GetEnumerator As IEnumerator
    Implements IEnumerable.GetEnumerator

Implements

IEnumerable..::.GetEnumerator()()()

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace


IIndexedSource(T).Indexes Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IIndexedSource<(Of <(T>)>)..::.Indexes Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<TRow> IIndexedSource<T>.Indexes { get; }
Visual Basic (Declaration)
Private ReadOnly Property Indexes As ScannerCollection(Of TRow)
    Implements IIndexedSource(Of T).Indexes

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).CreateNew Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.CreateNew Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Func<TRow> IObservableSource<T>.CreateNew { get; }
Visual Basic (Declaration)
Private ReadOnly Property CreateNew As Func(Of TRow)
    Implements IObservableSource(Of T).CreateNew

Implements

IObservableSource<(Of <(T>)>)..::.CreateNew

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).IsDeletedStateAvailable Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.IsDeletedStateAvailable { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsDeletedStateAvailable As Boolean
    Implements IObservableSource(Of T).IsDeletedStateAvailable

Implements

IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).SupportsChangingEvent Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsChangingEvent { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangingEvent As Boolean
    Implements IObservableSource(Of T).SupportsChangingEvent

Implements

IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IObservableSource(T).SupportsItemOrdinals Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsItemOrdinals { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsItemOrdinals As Boolean
    Implements IObservableSource(Of T).SupportsItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


ICollection(T).IsReadOnly Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.ICollection<(Of <(T>)>)..::.IsReadOnly Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<T>.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements ICollection(Of T).IsReadOnly

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IList(T).Item Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IList<(Of <(T>)>)..::.Item Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
TRow IList<T>.Item[
    int ordinal
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    ordinal As Integer _
) As TRow Implements IList(Of T).Item

Parameters

ordinal
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.Item[([(Int32])])

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IListSource.ContainsListCollection Property

[image]

.NET Framework Class Library
IndexedDataTable<(Of <(TRow>)>)..::.IListSource..::.ContainsListCollection Property
IndexedDataTable<(Of <(TRow>)>) Class See Also

Namespace: C1.LiveLinq.AdoNet
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IListSource.ContainsListCollection { get; }
Visual Basic (Declaration)
Private ReadOnly Property ContainsListCollection As Boolean
    Implements IListSource.ContainsListCollection

Implements

IListSource..::.ContainsListCollection

See Also

IndexedDataTable<(Of <(TRow>)>) Class
C1.LiveLinq.AdoNet Namespace


IIndexedSource(T).Indexes Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IIndexedSource<(Of <(T>)>)..::.Indexes Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<T> IIndexedSource<T>.Indexes { get; }
Visual Basic (Declaration)
Private ReadOnly Property Indexes As ScannerCollection(Of T)
    Implements IIndexedSource(Of T).Indexes

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IObservableSource(T).CreateNew Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.CreateNew Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Func<T> IObservableSource<T>.CreateNew { get; }
Visual Basic (Declaration)
Private ReadOnly Property CreateNew As Func(Of T)
    Implements IObservableSource(Of T).CreateNew

Implements

IObservableSource<(Of <(T>)>)..::.CreateNew

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IObservableSource(T).IsDeletedStateAvailable Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.IsDeletedStateAvailable { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsDeletedStateAvailable As Boolean
    Implements IObservableSource(Of T).IsDeletedStateAvailable

Implements

IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IObservableSource(T).SupportsChangingEvent Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsChangingEvent { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangingEvent As Boolean
    Implements IObservableSource(Of T).SupportsChangingEvent

Implements

IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IObservableSource(T).SupportsItemOrdinals Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsItemOrdinals { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsItemOrdinals As Boolean
    Implements IObservableSource(Of T).SupportsItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.AllowEdit Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.AllowEdit Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.AllowEdit { get; }
Visual Basic (Declaration)
Private ReadOnly Property AllowEdit As Boolean
    Implements IBindingList.AllowEdit

Implements

IBindingList..::.AllowEdit

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.AllowNew Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.AllowNew Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.AllowNew { get; }
Visual Basic (Declaration)
Private ReadOnly Property AllowNew As Boolean
    Implements IBindingList.AllowNew

Implements

IBindingList..::.AllowNew

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.AllowRemove Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.AllowRemove Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.AllowRemove { get; }
Visual Basic (Declaration)
Private ReadOnly Property AllowRemove As Boolean
    Implements IBindingList.AllowRemove

Implements

IBindingList..::.AllowRemove

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.IsSorted Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.IsSorted Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.IsSorted { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsSorted As Boolean
    Implements IBindingList.IsSorted

Implements

IBindingList..::.IsSorted

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.SortDirection Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.SortDirection Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ListSortDirection IBindingList.SortDirection { get; }
Visual Basic (Declaration)
Private ReadOnly Property SortDirection As ListSortDirection
    Implements IBindingList.SortDirection

Implements

IBindingList..::.SortDirection

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.SortProperty Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.SortProperty Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptor IBindingList.SortProperty { get; }
Visual Basic (Declaration)
Private ReadOnly Property SortProperty As PropertyDescriptor
    Implements IBindingList.SortProperty

Implements

IBindingList..::.SortProperty

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.SupportsChangeNotification Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.SupportsChangeNotification Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsChangeNotification { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangeNotification As Boolean
    Implements IBindingList.SupportsChangeNotification

Implements

IBindingList..::.SupportsChangeNotification

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.SupportsSearching Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.SupportsSearching Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsSearching { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsSearching As Boolean
    Implements IBindingList.SupportsSearching

Implements

IBindingList..::.SupportsSearching

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IBindingList.SupportsSorting Property

[image]

.NET Framework Class Library
IndexedCollection<(Of <(T>)>)..::.IBindingList..::.SupportsSorting Property
IndexedCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Collections
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsSorting { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsSorting As Boolean
    Implements IBindingList.SupportsSorting

Implements

IBindingList..::.SupportsSorting

See Also

IndexedCollection<(Of <(T>)>) Class
C1.LiveLinq.Collections Namespace


IIndexScanner(T).Definition Property

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.IIndexScanner<(Of <(T>)>)..::.Definition Property
Index<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IndexDefinition<T> IIndexScanner<T>.Definition { get; }
Visual Basic (Declaration)
Private ReadOnly Property Definition As IndexDefinition(Of T)
    Implements IIndexScanner(Of T).Definition

Implements

IIndexScanner<(Of <(T>)>)..::.Definition

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IIndexScanner(T).ParentScanner Property

[image]

.NET Framework Class Library
Index<(Of <(T>)>)..::.IIndexScanner<(Of <(T>)>)..::.ParentScanner Property
Index<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
IIndexScanner<T> IIndexScanner<T>.ParentScanner { get; }
Visual Basic (Declaration)
Private ReadOnly Property ParentScanner As IIndexScanner(Of T)
    Implements IIndexScanner(Of T).ParentScanner

Implements

IIndexScanner<(Of <(T>)>)..::.ParentScanner

See Also

Index<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(KeyValuePair(LambdaExpression, Index(T))).IsReadOnly Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.ICollection<(Of <(KeyValuePair<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)>)>)..::.IsReadOnly Property
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<KeyValuePair<LambdaExpression, Index<T>>>.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements ICollection(Of KeyValuePair(Of LambdaExpression, Index(Of T))).IsReadOnly

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).Item Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.Item Property
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Index<T> IDictionary<LambdaExpression, Index<T>>.Item[
    LambdaExpression key
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    key As LambdaExpression _
) As Index(Of T) Implements IDictionary(Of LambdaExpression, Index(Of T)).Item

Parameters

key
Type: System.Linq.Expressions..::.LambdaExpression

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.Item[([(TKey])])

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).Keys Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.Keys Property
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ICollection<LambdaExpression> IDictionary<LambdaExpression, Index<T>>.Keys { get; }
Visual Basic (Declaration)
Private ReadOnly Property Keys As ICollection(Of LambdaExpression)
    Implements IDictionary(Of LambdaExpression, Index(Of T)).Keys

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.Keys

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IDictionary(LambdaExpression, Index(T)).Values Property

[image]

.NET Framework Class Library
IndexCollection<(Of <(T>)>)..::.IDictionary<(Of <(LambdaExpression, Index<(Of <(T>)>)>)>)..::.Values Property
IndexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ICollection<Index<T>> IDictionary<LambdaExpression, Index<T>>.Values { get; }
Visual Basic (Declaration)
Private ReadOnly Property Values As ICollection(Of Index(Of T))
    Implements IDictionary(Of LambdaExpression, Index(Of T)).Values

Implements

IDictionary<(Of <(TKey, TValue>)>)..::.Values

See Also

IndexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(IIndexScanner(T)).IsReadOnly Property

[image]

.NET Framework Class Library
ScannerCollection<(Of <(T>)>)..::.ICollection<(Of <(IIndexScanner<(Of <(T>)>)>)>)..::.IsReadOnly Property
ScannerCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<IIndexScanner<T>>.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements ICollection(Of IIndexScanner(Of T)).IsReadOnly

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly

See Also

ScannerCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection(Subindex(T)).IsReadOnly Property

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.ICollection<(Of <(Subindex<(Of <(T>)>)>)>)..::.IsReadOnly Property
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<Subindex<T>>.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements ICollection(Of Subindex(Of T)).IsReadOnly

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


IList(Subindex(T)).Item Property

[image]

.NET Framework Class Library
SubindexCollection<(Of <(T>)>)..::.IList<(Of <(Subindex<(Of <(T>)>)>)>)..::.Item Property
SubindexCollection<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.Indexing
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Subindex<T> IList<Subindex<T>>.Item[
    int ordinal
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    ordinal As Integer _
) As Subindex(Of T) Implements IList(Of Subindex(Of T)).Item

Parameters

ordinal
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.Item[([(Int32])])

See Also

SubindexCollection<(Of <(T>)>) Class
C1.LiveLinq.Indexing Namespace


ICollection.IsSynchronized Property

[image]

.NET Framework Class Library
View..::.ICollection..::.IsSynchronized Property
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection.IsSynchronized { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsSynchronized As Boolean
    Implements ICollection.IsSynchronized

Implements

ICollection..::.IsSynchronized

See Also

View Class
C1.LiveLinq.LiveViews Namespace


ICollection.SyncRoot Property

[image]

.NET Framework Class Library
View..::.ICollection..::.SyncRoot Property
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object ICollection.SyncRoot { get; }
Visual Basic (Declaration)
Private ReadOnly Property SyncRoot As Object
    Implements ICollection.SyncRoot

Implements

ICollection..::.SyncRoot

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.IsFixedSize Property

[image]

.NET Framework Class Library
View..::.IList..::.IsFixedSize Property
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IList.IsFixedSize { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsFixedSize As Boolean
    Implements IList.IsFixedSize

Implements

IList..::.IsFixedSize

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IList.Item Property

[image]

.NET Framework Class Library
View..::.IList..::.Item Property
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object IList.Item[
    int index
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    index As Integer _
) As Object Implements IList.Item

Parameters

index
Type: System..::.Int32

Implements

IList..::.Item[([(Int32])])

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IListSource.ContainsListCollection Property

[image]

.NET Framework Class Library
View..::.IListSource..::.ContainsListCollection Property
View Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IListSource.ContainsListCollection { get; }
Visual Basic (Declaration)
Private ReadOnly Property ContainsListCollection As Boolean
    Implements IListSource.ContainsListCollection

Implements

IListSource..::.ContainsListCollection

See Also

View Class
C1.LiveLinq.LiveViews Namespace


IIndexedSource(T).Indexes Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IIndexedSource<(Of <(T>)>)..::.Indexes Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<T> IIndexedSource<T>.Indexes { get; }
Visual Basic (Declaration)
Private ReadOnly Property Indexes As ScannerCollection(Of T)
    Implements IIndexedSource(Of T).Indexes

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).CreateNew Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.CreateNew Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Func<T> IObservableSource<T>.CreateNew { get; }
Visual Basic (Declaration)
Private ReadOnly Property CreateNew As Func(Of T)
    Implements IObservableSource(Of T).CreateNew

Implements

IObservableSource<(Of <(T>)>)..::.CreateNew

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).IsDeletedStateAvailable Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.IsDeletedStateAvailable { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsDeletedStateAvailable As Boolean
    Implements IObservableSource(Of T).IsDeletedStateAvailable

Implements

IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).SupportsChangingEvent Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsChangingEvent { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangingEvent As Boolean
    Implements IObservableSource(Of T).SupportsChangingEvent

Implements

IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(T).SupportsItemOrdinals Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<T>.SupportsItemOrdinals { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsItemOrdinals As Boolean
    Implements IObservableSource(Of T).SupportsItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IList(T).Item Property

[image]

.NET Framework Class Library
View<(Of <(T>)>)..::.IList<(Of <(T>)>)..::.Item Property
View<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
T IList<T>.Item[
    int index
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    index As Integer _
) As T Implements IList(Of T).Item

Parameters

index
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.Item[([(Int32])])

See Also

View<(Of <(T>)>) Class
C1.LiveLinq.LiveViews Namespace


IIndexedSource(ViewRow).Indexes Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IIndexedSource<(Of <(ViewRow>)>)..::.Indexes Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<ViewRow> IIndexedSource<ViewRow>.Indexes { get; }
Visual Basic (Declaration)
Private ReadOnly Property Indexes As ScannerCollection(Of ViewRow)
    Implements IIndexedSource(Of ViewRow).Indexes

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(ViewRow).CreateNew Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IObservableSource<(Of <(ViewRow>)>)..::.CreateNew Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Func<ViewRow> IObservableSource<ViewRow>.CreateNew { get; }
Visual Basic (Declaration)
Private ReadOnly Property CreateNew As Func(Of ViewRow)
    Implements IObservableSource(Of ViewRow).CreateNew

Implements

IObservableSource<(Of <(T>)>)..::.CreateNew

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(ViewRow).IsDeletedStateAvailable Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IObservableSource<(Of <(ViewRow>)>)..::.IsDeletedStateAvailable Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<ViewRow>.IsDeletedStateAvailable { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsDeletedStateAvailable As Boolean
    Implements IObservableSource(Of ViewRow).IsDeletedStateAvailable

Implements

IObservableSource<(Of <(T>)>)..::.IsDeletedStateAvailable

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(ViewRow).SupportsChangingEvent Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IObservableSource<(Of <(ViewRow>)>)..::.SupportsChangingEvent Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<ViewRow>.SupportsChangingEvent { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangingEvent As Boolean
    Implements IObservableSource(Of ViewRow).SupportsChangingEvent

Implements

IObservableSource<(Of <(T>)>)..::.SupportsChangingEvent

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IObservableSource(ViewRow).SupportsItemOrdinals Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IObservableSource<(Of <(ViewRow>)>)..::.SupportsItemOrdinals Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IObservableSource<ViewRow>.SupportsItemOrdinals { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsItemOrdinals As Boolean
    Implements IObservableSource(Of ViewRow).SupportsItemOrdinals

Implements

IObservableSource<(Of <(T>)>)..::.SupportsItemOrdinals

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection(ViewRow).IsReadOnly Property

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection<(Of <(ViewRow>)>)..::.IsReadOnly Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection<ViewRow>.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements ICollection(Of ViewRow).IsReadOnly

Implements

ICollection<(Of <(T>)>)..::.IsReadOnly

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList(ViewRow).Item Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IList<(Of <(ViewRow>)>)..::.Item Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ViewRow IList<ViewRow>.Item[
    int ordinal
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    ordinal As Integer _
) As ViewRow Implements IList(Of ViewRow).Item

Parameters

ordinal
Type: System..::.Int32

Implements

IList<(Of <(T>)>)..::.Item[([(Int32])])

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection.IsSynchronized Property

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection..::.IsSynchronized Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool ICollection.IsSynchronized { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsSynchronized As Boolean
    Implements ICollection.IsSynchronized

Implements

ICollection..::.IsSynchronized

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


ICollection.SyncRoot Property

[image]

.NET Framework Class Library
ViewRowCollection..::.ICollection..::.SyncRoot Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object ICollection.SyncRoot { get; }
Visual Basic (Declaration)
Private ReadOnly Property SyncRoot As Object
    Implements ICollection.SyncRoot

Implements

ICollection..::.SyncRoot

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.IsFixedSize Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.IsFixedSize Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IList.IsFixedSize { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsFixedSize As Boolean
    Implements IList.IsFixedSize

Implements

IList..::.IsFixedSize

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.IsReadOnly Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.IsReadOnly Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IList.IsReadOnly { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsReadOnly As Boolean
    Implements IList.IsReadOnly

Implements

IList..::.IsReadOnly

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IList.Item Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IList..::.Item Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
Object IList.Item[
    int ordinal
] { get; set; }
Visual Basic (Declaration)
Private Property Item ( _
    ordinal As Integer _
) As Object Implements IList.Item

Parameters

ordinal
Type: System..::.Int32

Implements

IList..::.Item[([(Int32])])

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.IsSorted Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.IsSorted Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.IsSorted { get; }
Visual Basic (Declaration)
Private ReadOnly Property IsSorted As Boolean
    Implements IBindingList.IsSorted

Implements

IBindingList..::.IsSorted

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.SortDirection Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.SortDirection Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ListSortDirection IBindingList.SortDirection { get; }
Visual Basic (Declaration)
Private ReadOnly Property SortDirection As ListSortDirection
    Implements IBindingList.SortDirection

Implements

IBindingList..::.SortDirection

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.SortProperty Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.SortProperty Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
PropertyDescriptor IBindingList.SortProperty { get; }
Visual Basic (Declaration)
Private ReadOnly Property SortProperty As PropertyDescriptor
    Implements IBindingList.SortProperty

Implements

IBindingList..::.SortProperty

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.SupportsChangeNotification Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.SupportsChangeNotification Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsChangeNotification { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsChangeNotification As Boolean
    Implements IBindingList.SupportsChangeNotification

Implements

IBindingList..::.SupportsChangeNotification

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.SupportsSearching Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.SupportsSearching Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsSearching { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsSearching As Boolean
    Implements IBindingList.SupportsSearching

Implements

IBindingList..::.SupportsSearching

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IBindingList.SupportsSorting Property

[image]

.NET Framework Class Library
ViewRowCollection..::.IBindingList..::.SupportsSorting Property
ViewRowCollection Class See Also

Namespace: C1.LiveLinq.LiveViews
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
bool IBindingList.SupportsSorting { get; }
Visual Basic (Declaration)
Private ReadOnly Property SupportsSorting As Boolean
    Implements IBindingList.SupportsSorting

Implements

IBindingList..::.SupportsSorting

See Also

ViewRowCollection Class
C1.LiveLinq.LiveViews Namespace


IIndexedSource(T).Indexes Property

[image]

.NET Framework Class Library
Ordering<(Of <(T>)>)..::.IIndexedSource<(Of <(T>)>)..::.Indexes Property
Ordering<(Of <(T>)>) Class See Also

Namespace: C1.LiveLinq
Assembly: C1.LiveLinq (in C1.LiveLinq.dll)

Syntax

C#
ScannerCollection<T> IIndexedSource<T>.Indexes { get; }
Visual Basic (Declaration)
Private ReadOnly Property Indexes As ScannerCollection(Of T)
    Implements IIndexedSource(Of T).Indexes

Implements

IIndexedSource<(Of <(T>)>)..::.Indexes

See Also

Ordering<(Of <(T>)>) Class
C1.LiveLinq Namespace