NetInverse Developers Blog

May 3, 2010
Category: .Net — Tags: — admin @ 11:24 pm

A sample of LINQ provider.

using System;
using System.Collections;

namespace LINQSample
{
    class Program
    {
        static void Main(string[] args)
        {
            var myNumberServer = new MyNumberServer(323, 2);
            var query = from a in myNumberServer
                        where a != 3
                        select a;

            foreach(var item in query)
            {
                Console.WriteLine(item);
            }
        }
    }

    public class MyNumberServer
    {
        private readonly int _numberToServer;
        private readonly int _length;

        public MyNumberServer(int init, int length)
        {
            _numberToServer = init;
            _length = length;
        }

        public IEnumerator GetEnumerator()
        {
            for (int i = 0; i < _length; i++)
            {
                yield return _numberToServer;
            }
        }
    }

    public static class Extensions
    {
        public static IEnumerable Where(this MyNumberServer source, Func<int, bool> predicate)
        {
            foreach (int item in source)
            {
                if (predicate(item))
                {
                    yield return item;
                }
            }
        }

        public static IEnumerable Select(this MyNumberServer source, Func<object, object> selector)
        {
            foreach (var item in source)
            {
                yield return selector(item);
            }
        }

        public static IEnumerable Cast(this MyNumberServer source)
        {
            foreach (var item in source)
            {
                yield return (int)(item);
            }
        }
    }
 }

Note: This is a sample from the book “Essential LINQ”.

Category: .Net — Tags: — admin @ 10:12 pm

IQueryable<T> is the type used in LINQ to SQL queries. IQueryable<T> differs from IEnumerable<T> in that it includes an expression tree. In particular, the type takes the following shape:

public interface IQueryable<T> : IEnumerable<T>, IQueryable, IEnumerable
{
}

The important interface in this declaration is IQueryable:

public interface IQueryable: IEnumerable
{
   Type ElementType {get;}
   Expression Expression {get;}
   IQueryProvider Provider {get;}
}

The key property  here is the middle one - Expression. IQueryable<T> implements IEnumerable<T>.

©2009 NetInverse. All rights reserved. Powered by WordPress