Below is a simple test case showing how to do LINQ operations on a simple array:

        public void LinqArrayTest()
        {
            String[] names = { "Burke", "Connor", "Frank",
                   "Everett", "Albert", "George",
                   "Harris", "David" };

            IEnumerable<string> query = from s in names
                               where s.Length == 5
                               orderby s
                               select s;

            List<String> results = query.ToList();

            Assert.AreEqual(3, results.Count);
            String[] expected = new String[] {"Burke", "David", "Frank"};
            for (int i = 0; i < results.Count; i++)
            {
                Assert.AreEqual(expected[i], results.ElementAt(i));
            }
        }

It is also possible to create runtime LINQ queries using lambda expressions to qualify conditional logic:

        [TestMethod()]
        public void LinqLambdaTest()
        {
            String[] items = { "cabbage", "broccoli", "carrot", "parsnip", "cauliflower" };

            IEnumerable<String> query = items;

            // additive query generation using lambda expressions
            query = query.Where(item => item.StartsWith("c"));
            query = query.Where(item => item.Length < 8);
            query = query.OrderByDescending(item => item.ToLower());

            List<String> results = query.ToList();

            Assert.AreEqual(2, results.Count);
            String[] expected = { "carrot", "cabbage" };
            for (int i = 0; i < results.Count; i++)
            {
                Assert.AreEqual(expected[i], results.ElementAt(i));
            }
        }

LINQ provides a simple, generalised query framework for operating on data collections within the .NET stack. There are framework plugins to support LINQ backed by various datastore technologies, these include: LINQ to SQL, LINQ to XML and LINQ to Entities.

Single Question Mark – nullable types

The single question mark syntax is somewhat obscure. Essentially it is short hand syntax for marking primitives as nullable. System.Nullable is a generic struct that is essentially a wrapper to signify nullability. This can be used as shown below:

// a nullable type for int
int? thing = 12;

// is syntactically equivalent to
System.Nullable<int> otherThing = 12;

// can be any valid int value OR null
thing = -12;
thing = null;

// usage
//y is set to zero
int y = thing.GetValueOrDefault();
// but this will throw an exception as thing.HasValue == false
y = thing.Value;

Double Question Mark – non null assignment precedence

This one is a little obscure but can be quite handy, it is very similar to certain assignment constructs in Perl as it allows one to use precedence to assign a variable from other potential variables and is a nice way to deal with default values.

String thing = null;
String defaultThing = "nothing";

// standard trinary syntax
String otherThing = (thing != null) ? thing : defaultThing;

// syntactic sugar for the above
String sugaredThing = thing ?? defaultThing;

// can also chain things
otherThing = null;

// the first non-null value is the result of the assignment
String anotherThing = thing ?? otherThing ?? defaultThing;

// if all potentials are null, then the assignement is null)
anotherThing = thing ?? otherThing;

These concepts are all database-agnostic, but there are specific tools for use with Java, Hibernate, and Spring to assist in persistence strategy integration. For more information, see the wiki here:

https://dev.2paths.com/wiki/display/2pathsTECH/Persistence