MSDN Magazine - September 2008 - (Page 37)

Figure 6 Filtering the ArrayList ' From CastDemo in the sample: Dim items As New ArrayList items.Add("January") items.Add(1) items.Add("August") items.Add(14) items.Add("October") items.Add(25) items.Add("April") items.Add(38) ' Cast the ArrayList as a queryable group of strings ' (if the conversion to String failed for any element, ' this would raise an exception): Dim query = items.Cast(Of String)() Dim results = _ query.Where(Function(item) item.StartsWith("A")) Positioning within Sequences Given that LINQ uses deferred execution to retrieve data, and you may want to virtualize access to large sets of data, you need some way to retrieve a specific number of rows from a data source, starting at a particular offset within the data. To satisfy these needs, you can use the Enumerable.Take and Enumerable.Skip methods. These methods allow you to specify the number of rows to take and the number of rows to skip before starting to take rows. The sample project includes the following simple code, which returns 5 rows after skipping 10 rows: Dim db As New SimpleDataContext Dim products = (From p In db.Products _ Order By p.ProductName _ Select String.Format("{0}: {1}", p.ProductID, p.ProductName)). _ Skip(10).Take(5) Finally, the Enumerable.AsEnumerable method enables you to treat a source type as IEnumerable so you can use methods of IEnumerable rather than methods in the implemented class. This method is useful in specific circumstances, but it’s unlikely that you’ll need it in general coding. The complex example in the documentation explains this method. If you need to coerce your own class to behave as if it were of type IEnumerable, then you should definitely take a look at the Enumerable.AsEnumerable method. You can use the Enumerable.TakeWhile and Enumerable.SkipWhile methods to take and skip values in a sequence while some condition is true. The TakeWhile method takes values while a condition is true and returns a sequence containing all the values it took. The SkipWhile method skips values as long as the condition is true and returns the remainder of the input sequence. The sample procedure in Figure 7 creates a generic List(Of Integer) containing random integers. It then takes values while each item is less than a specific number and displays the results (the Insights: Generics and Type Inference Ken’s been demonstrating a number of interesting ways to use lambdas and extension methods together. Let’s take a look at the example where he selects all the Strings that start with the letter “A”: Dim results = query.Where(Function(item) item.StartsWith("A")) the context. Effectively, the lambda is treated exactly the same as if you’d typed this: Function(item As String) item.StartsWith("A") This defines a lambda expression that operates over each element in the sequence. But how does the compiler know that item has a StartsWith method? How does the IDE know to provide IntelliSense after “item dot”? Is that a late-bound call? No. What’s happening here is that the compiler’s doing some work on your behalf through a process called “lambda parameter type inference.” Let’s look at the signature for the Where extension method, shown here: ® This process works the same for lambdas that take multiple parameters, saving you keystrokes and making your code more concise. Now consider a slightly more complicated example: Function Sum(Of T)(ByVal x As T, ByVal y As T) As T End Function Dim total = Sum(1, 2.0) _ Function Where(Of T)(source As IEnumerable(Of T), _ predicate As Func(Of T, Boolean)) As IEnumerable(Of T) Now when the compiler sees a call to this extension method, it converts it to something like this: Dim results = Enumerable.Where(query, Function(item) _ item.StartsWith("A")) Notice that no generic parameters were passed to the method— using the (Of T) syntax. You could pass them explicitly, but if you don’t, the compiler will try to infer the generic type(s) based on the arguments passed in. In this case, the compiler has one generic parameter, “T,” which is used in three places (in two arguments and a return value). It also has one type hint, which comes from the parameter query. The query’s type is IEnumerable(Of String), and the corresponding parameter on Where has type IEnumerable(Of T). Thus the compiler is able to infer that T must be of type String. As a result, the compiler does not need to be given a type for the lambda expression’s parameter since it already knows it from msdnmagazine.com What type should T be now? There are two type hints: one that indicates it’s an Integer and one that indicates it’s a Double. As a result, if you hover over Sum you’ll see that the compiler has inferred T to be a Double (which is a type wide enough to handle both an integer and a double). In Visual Basic 2005 this would have caused a compile error (try it!); but in Visual Basic 2008 the compiler uses the new dominant type algorithm to select a type that will work for all arguments. How this algorithm works is actually pretty complicated, but you can read a simplified explanation of it in Section 8.13 of the Visual Basic 9.0 Language Specification (see go.microsoft.com/ fwlink/?LinkId=123647). What about this case? Dim total = Sum(1D, 2) Here the compiler will infer T to be of type Decimal since it’s one of the types provided, and converting an Integer to a Decimal is a widening conversion (see go.microsoft.com/fwlink/?LinkId=123649 for more on widening and narrowing conversions). —Jonathan Aneja, Microsoft Visual Basic Team September 2008 37 http://go.microsoft.com/fwlink/?LinkId=123647 http://go.microsoft.com/fwlink/?LinkId=123647 http://go.microsoft.com/fwlink/?LinkId=123649 http://msdnmagazine.com

Table of Contents Feed for the Digital Edition of MSDN Magazine - September 2008

MSDN Magazine - September 2008 Contents Toolbox CLR Inside Out Data Points Advanced Basics Office Space Cutting Edge Hierarchy ID New Features for Microsoft SQL Server 2008 Prism Data Services Advanced WPF Test Run Security Briefs Foundations { End Bracket }

MSDN Magazine - September 2008

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.