Mike and I had an interesting discussion this afternoon about LINQ and how it interprets enumerable rows. Needless to say, some test code had to be written to prove or disprove some theories.

 

 

Our thought experiment was what if you had an interface to an object and wanted to expose it to LINQ for query? Did you need to implement IEnumerable on the concrete class, or the interface level? Would it work on both? What about strongly typing and intellisense in the IDE?

 

 

It turns out that you can implement it in either place. But if you implement it only in the Concrete class then LINQ can’t see the IEnumerable to give you intellisense. 

 

 

OK, how did we test this? We took a Row as our base object. We want to store a collection of Rows and iterate over them using a Table (something we do quite a bit). In VistaDB all Table objects actually implement the ITable interface to give them a common set of controls (things like RowCount).

 

 

Row – Stores Data

ITable – Interface for the Table

Table – concrete class for the Table

 

 

Once you have this done you can ask some interesting questions with LINQ.

 

Give me all the rows that have data > 0 starting with item #2

 

 

 

This would be MUCH harder to do without LINQ. This is a powerful query with intellisense. Don’t think of this in terms of SQL, you could do this with SQL as a single execute as well. Think DDA. In DDA you would have to set .First(), then .MoveNext() and then move through each row checking for the length > 0.

 

 

No, this is NOT supported today. We were just using it as a thought experiment. Could you expose something like that through the IEnumerable interface and actually have it work?

 

The answer is yes. It actually looks like you could do it. Now, how much work would it be in VistaDB? No idea yet. But it is an interesting thought.

 

  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LinqTestEnumerator
{
    class Program
    {
        static void Main(string[] args)
        {
            Table firsttable = new Table();

            var foundrows = firsttable.Where(c => c.StringData.Length > 0).Skip(1);
            Console.WriteLine("The following rows where found after the filter was applied");
            foreach (var c in foundrows)
            {
                Console.WriteLine(c.StringData);
            }

            var singlerow = firsttable.First(c => c.StringData.Length > 0);
            Console.WriteLine("Single row: " + singlerow.StringData);


            ITable secondtable = new Table();
            var foundrows2 = secondtable.Where(c => c.StringData.Length > 0).Skip(1);
            Console.WriteLine("The following were found using the ITable class rather than the Table concrete class");
            foreach (var c in foundrows)
            {
                Console.WriteLine(c.StringData);
            }

        }
    }

    /// <summary>
    /// This is our BASE for everything here.  We are trying to store a list of rows for this test
    /// </summary>
    public class Row
    {
        public string StringData;
    }

    /// <summary>
    /// An interface for Table objects - common required data
    /// Note that IEnumerable MUST be implemented at this level, not at the Table level or LINQ can't see it
    /// </summary>
    public interface ITable : IEnumerable<Row>
    {
        // How many rows are in this table
        int RowCount();
    }

    public class Table : ITable
    {
        List<Row> rows;

        public Table()
        {
            rows = new List<Row> { new Row { StringData = "row data 1" }, new Row { StringData = "row data 2" }, new Row { StringData = "row data 3" } };
        }

        public IEnumerator<Row> GetEnumerator()
        {
            return (rows.GetEnumerator());
        }

        // Note that the namespace collision between the Generic and normal Collections of IEnumerator
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return (rows.GetEnumerator());
        }
        
        public int RowCount()
        {
            return (rows.Count);
        }
    }
}