http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx

 

About Rx

Rx is a library for composing asynchronous and event-based programs using observable collections.

The “A” in “AJAX” stand for asynchronous, and indeed modern Web-based and Cloud-based applications are fundamentally asynchronous. In fact, Silverlight bans all blocking networking and threading operations. Asynchronous programming in by no means restricted to Web and Cloud scenarios, however. Traditional desktop applications also have to maintain responsiveness in the face of long latency IO operations and other expensive background tasks.

Another common attribute of interactive applications, whether Web/Cloud or client-based, is that they are event-driven. The user interacts with the application via a GUI that receives event streams asynchronously from the mouse, keyboard, and other inputs.

Rx is a superset of the standard LINQ sequence operators that exposes asynchronous and event-based computations as push-based, observable  collections via the new .NET 4.0 interfaces IObservable<T> and IObserver<T>.  These are the mathematical dual of the familiar IEnumerable<T> and IEnumerator<T> interfaces for pull-based, enumerable collections in the .NET framework.

The IEnumerable<T> and IEnumerator<T> interfaces allow developers to create reusable abstractions to consume and transform values from a wide range of concrete enumerable collections such as arrays, lists, database tables, and XML documents. Similarly, Rx allows programmers to glue together complex event processing and asynchronous computations using LINQ queries over observable collections such as .NET events and APM-based computations, PFx concurrent Task<T>,  the Windows 7 Sensor and Location APIs, SQL StreamInsight temporal event streams , F# first-class events, and async workflows.

Play with Rx, stress it, evaluate it, and tell us what you think.

Click Here to Watch What’s New

9 our of 10 studies prove: Resharper make your your hair grow back, your dog come home (yes even if he died), your wife will love you again and your kids will listen to you.

OK perhaps it is not a country music song played backwards.

BUT your nuts to even think about wasting all that time not using it. For someone who knows it is people not tools that always win, this is my only exception in 20 years that I will stand behind.

Why stare at a keyboard for hours wondering how to navigate a nasty tangled refactoring you know you must do when you can do the right thing AND make the 5:30 train.

Me? I hit the shift-ctrl-space repeatedly and am shocked when nothing happens. Then I install it and life is good again.

ReSharper 4.5 Released

April 8, 2009

In This Issue

Introduction
Performance and Memory Usage Improvements
Solution-Wide Code Inspections

VB9 Support
Extended Naming Style Configuration
Other Enhancements

Introduction

ReSharper 4.5 is finally out, so your next productivity upgrade is just a mouse click away!

As announced, the new version features major improvements in performance and memory usage. After all, what is a productivity tool for if not for being agile, robust and responsive?

In addition to focusing on performance enhancements, we also added a number of intelligence features and improvements.

We’ve prepared a short Flash movie to introduce the new features in ReSharper 4.5. Get the hang of things in just a few minutes!

For users of older versions we have a ReSharper 3.0 vs. ReSharper 4.5 Comparison matrix.

However, if you believe a thousand words say more than a picture does, or even a movie, go ahead and read the descriptions below :)

Alex Morozov
NET product marketing manager 
JetBrains

Performance and Memory Usage Improvements

We have managed to make ReSharper load and work faster and more smoothly in general, particularly on big (and we mean BIG) solutions:

• Wall-time measurements of solution loading show 20 to 40 percent acceleration until the solution is ready for code editing.
• Web site loading time has also been reduced by a third.
• For instance, a certain mixed-language solution consisting of about 15 thousand classes now takes only 70 seconds to load, and this includes making every ReSharper feature available.

The list of significantly accelerated operations includes:

• renaming symbols
• finding commonly used symbols
• creating symbols from usage
• analyzing large XAML files.

We’ve also cut down the volume of memory resources required to analyze jumbo autogenerated code files, which should especially benefit those who work with ASP.NET and LINQ to SQL.

Solution-Wide Code Inspections

To enable you to detect unused non-private members on the fly, we have enlisted the help of our ever-improving solution-wide analysis. We have introduced a set of specialized code inspections that only work when you let ReSharper analyze your whole solution. They help you discover:

• Unused non-private declarations
• Unused return values of non-private methods
• Unaccessed non-private fields
• Unused parameters in non-private members
• Abstract or virtual events that are never invoked
• Unassigned fields
• Members and types that can be made internal instead of public

Look for these inspections in your code and on the Marker Bar, highlighted as warnings or suggestions. In addition, new code annotations are available that you can use to mark certain unused non-private types and members to prevent ReSharper from fussing about them.

VB9 Support – We can forgive this transgression (Damon)

Visual Basic .NET developers can now benefit from VB9 language support that includes implicitly typed local variables, object initializers, anonymous types, extension methods, lambda expressions, partial methods, and embedded XML. VB9 support is all around you, courtesy of new context actions, code completion, refactorings, and Parameter Info, among other supporting features.

Extended Naming Style Configuration

Now you can define custom naming style settings for different languages and symbols including:

• types
• namespaces
• interfaces
• parameters
• method properties and events
• static and instance fields, etc.

For every kind of symbol, you can configure one of five casing options, prefixes and suffixes, variations for different access rights, abbreviations to preserve, or enable naming inspections. As a result, you can precisely align the way ReSharper completes and generates code with your specific coding guidelines.

Other Enhancements

• Go to Implementation – This new navigation feature lets you jump from usage of a base type or member to any of its end implementations, bypassing intermediate steps in the inheritance chain.
• New and Improved Refactorings – ReSharper 4.5 has added Inline Field to its family of Inline refactorings. Rename refactoring now provides name completion, and some of the other refactorings were thoroughly refactored themselves, to make them perform faster.
• Native MSTest Support – Initially available through VstsUnit Plugin and then Gallio, MSTest support has finally made its way to being provided natively in ReSharper, on par with nUnit.
• Wider Cross-Language Capabilities – Quick-fixes and context actions work better in many cross-language scenarios: for example, you can extend a control written in VB.NET+XAML by choosing "create from usage" right from a C# usage. Add increased coverage for XAML and ASP.NET, and you get a substantial package of improvements.
• Smoother Language and Framework Support – Following the tradition of ReSharper 4.1, we have improved compatibility with F#, Compact Framework, Silverlight 2, and other languages and tools.

Grab your all-new productivity – download ReSharper 4.5 now at http://www.jetbrains.com/resharper/download.

ReSharper 4.5 is provided as a free upgrade from ReSharper 4.0. If you own an older version, please contact us to check your upgrade availability at sales@jetbrains.com.

JetBrains Team

• Sergey
  Anchipolevsky

• Igor
  Alshannikov

• Alexander
  Anisimov

• Dmitry
  Avdeev

• Sergey
  Baranov

• Yury
  Belyaev

• Natalia
  Belyaeva

• Elena
  Bukreeva

• Bulenkov
  Konstantin

• Jana
  Charif

• Nikolay
  Chashnikov

• Alexander
  Chernikov

• Roman
  Chernyatchik

• Sergey
  Coox

• Sergey
  Dmitriev

• Ilia
  Dumov

• Kirill
  Falk

• Michael
  Gerasimov

• Sergey
  Golovachev

• Alexey
  Gopachenko

• Peter
  Gromov

• Michaela
  Hroncová

• Dmitry
  Jemerov

• Maria
  Khalusova

• Valentin
  Kipiatkov

• Cyril
  Konopko

• Anna
  Kozlova

• Mikhail
  Kropotov

• Eugene
  Kudelevsky

• Alexey
  Kudravtsev

• Olga
  Lobacheva

• Vyacheslav
  Lukianov

• Anton
  Makeev

• Egor
  Malyshev

• Maria
  Marakulina

• Kirill
  Maximov

• Sasha
  Maximova

• Irina
  Megorskaya

• Lucie
  Morawiecova

• Alexander
  Morozov

• Maxim
  Mossienko

• Ekaterina
  Musienko

• Ann
  Oreshnikova

• Eugene
  Pasynkov

• Vaclav
  Pech

• Alexey
  Pegov

• Eugene
  Petrenko

• Irina
  Petrovskaya

• Mikhail
  Pilin

• Julia
  Repina

• Elizaveta
  Revyakina

• Ilya
  Ryzhenkov

• Andrew
  Serebryansky

• Ilya
  Sergey

• Maxim
  Shafirov

• Tatiana
  Slavina

• Olesya
  Smirnova

• Konstantin
  Solomatov

• Oleg
  Stepanov

• Pavel
  Sher

• Ekaterina
  Shliakhovetskaja

• Oleg
  Shpynov

• Gregory
  Shrago

• Eugene
  Toporov

• George
  Udov

• Sergey
  Vasiliev

• Natalie
  Yaremych

• Yegor
  Yarko

• Timur
  Zambalayev

• Sergey
  Zhukov

• Eugene
  Zhuravlev

• Alexander
  Zverev

….but F# removes side-effect corruption so uh.. there goes my analogy……

Starting from scratch with F#? Click here.

Functional programming is so addictive. It reminds me when I could code with no team, no deadline, no broken processes or cultures to navigate. I do hope this becomes a common option for general development or at least C# continues to borg functional ideas…

For a larger collection of F# samples, see:

http://go.microsoft.com/fwlink/?LinkID=124614

// F# Tutorial File
//
// This file contains sample code to guide you through the
// primitives of the F# language.
//
// Contents:
//   – Simple computations
//   – Functions on integers
//   – Tuples
//   – Booleans
//   – Strings
//   – Lists
//   – Arrays
//   – More Collections
//   – Functions
//   – Types: unions
//   – Types: records
//   – Types: classes
//   – Types: interfaces
//   – Types: classes with interface implementations
//   – Printing

// Turn on the lightweight syntax
#light

// open some standard namespaces
openSystem

// Simple computations
// —————————————————————
// Here are some simple computations.  Note how code can be documented
// with ‘///’ comments.  Hover over any reference to a variable to
// see its documentation.

/// A very simple constant integer
letint1 = 1

/// A second very simple constant integer
letint2 = 2

/// Add two integers
letint3 = int1 + int2

// Functions on integers
// —————————————————————

/// A function on integers
letf x = 2*x*x – 5*x + 3

/// The result of a simple computation
letresult = f (int3 + 4)

/// Another function on integers
letincrement x = x + 1

/// Compute the factorial of an integer
let rec factorial n =ifn=0then1elsen * factorial (n-1)

/// Compute the highest-common-factor of two integers
let rec hcf a b = // notice: 2 parameters separated by spaces
ifa=0thenb
elif a<bthenhcf a (b-a) // notice: 2 arguments separated by spaces
elsehcf (a-b) b
// note: function arguments are usually space separated
// note: ‘let rec’ defines a recursive function
// Tuples
// —————————————————————

// A simple tuple of integers
letpointA = (1, 2, 3)

// A simple tuple of an integer, a string and a double-precision floating point number
letdataB = (1,“fred”, 3.1415)

/// A function that swaps the order of two values in a tuple
letSwap (a, b) = (b, a)

// Booleans
// —————————————————————

/// A simple boolean value
letboolean1 =true

/// A second simple boolean value
letboolean2 =false

/// Compute a new boolean using ands, ors, and nots
letboolean3 = not boolean1 && (boolean2 ||false)

// Strings
// —————————————————————

/// A simple string
letstringA  =“Hello”

/// A second simple string
letstringB  =“world”

/// “Hello world” computed using string concatentation
letstringC  = stringA +” “+ stringB

/// “Hello world” computed using a .NET library function
letstringD = String.Join(” “,[| stringA; stringB |])
// Try re-typing the above line to see intellisense in action
// Note, ctrl-J on (partial) identifiers re-activates it

// Functional Lists
// —————————————————————

/// The empty list
letlistA = [ ]

/// A list with 3 integers
letlistB = [ 1; 2; 3 ]

/// A list with 3 integers, note :: is the ‘cons’ operation
letlistC = 1 :: [2; 3]

/// Compute the sum of a list of integers using a recursive function
let rec SumList xs =
matchxs with
| [] ->0
| y::ys ->y + SumList ys

/// Sum of a list
letlistD = SumList [1; 2; 3]

/// The list of integers between 1 and 10 inclusive
letoneToTen = [1..10]

/// The squares of the first 10 integers
letsquaresOfOneToTen = [forxin0..10->x*x ]

// Mutable Arrays
// —————————————————————

/// Create an array
letarr = Array.create 4“hello”
arr.[1] <-“world”
arr.[3] <-“don”

/// Compute the length of the array by using an instance method on the array object
letarrLength = arr.Length

// Extract a sub-array using slicing notation
letfront = arr.[0..2]

// More Collections
// —————————————————————

/// A dictionary with integer keys and string values
letlookupTable = dict [ (1,"One"); (2,"Two") ]

letoneString = lookupTable.[1]

// For some other common data structures, see:
//   System.Collections.Generic
//   Microsoft.FSharp.Collections
//   Microsoft.FSharp.Collections.Seq
//   Microsoft.FSharp.Collections.Set
//   Microsoft.FSharp.Collections.Map

// Functions
// —————————————————————

/// A function that squares its input
letSquare x = x*x

// Map a function across a list of values
letsquares1 = List.map Square [1; 2; 3; 4]
letsquares2 = List.map (funx->x*x) [1; 2; 3; 4]

// Pipelines
letsquares3 = [1; 2; 3; 4] |> List.map (funx->x*x)
letSumOfSquaresUpTo n =
[1..n]
|> List.map Square
|> List.sum

// Types: unions
// —————————————————————

typeExpr =
| Numofint
| AddofExpr * Expr
| Mul ofExpr * Expr
| Varofstring

let rec Evaluate (env:Map<string,int>) exp =
matchexpwith
| Num n->n
| Add (x,y)->Evaluate env x + Evaluate env y
| Mul (x,y)->Evaluate env x * Evaluate env y
| Var id ->env.[id]

letenvA = Map.of_list ["a",1 ;
"b",2 ;
"c",3 ]

letexpT1 = Add(Var“a”,Mul(Num 2,Var“b”))
letresT1 = Evaluate envA expT1

// Types: records
// —————————————————————

typeCard = { Name  : string;
Phone : string;
Ok    : bool }

letcardA = { Name =“Alf”; Phone =“(206) 555-8257″; Ok =false}
letcardB = { cardA withPhone =“(206) 555-4112″; Ok =true}
letShowCard c =
c.Name +” Phone: “+ c.Phone + (ifnot c.Okthen ” (unchecked)” else “”)

// Types: classes
// —————————————————————

/// A 2-dimensional vector
typeVector2D(dx:float, dy:float) =
// The pre-computed length of the vector
letlength = sqrt(dx*dx + dy*dy)
/// The displacement along the X-axis
memberv.DX = dx
/// The displacement along the Y-axis
memberv.DY = dy
/// The length of the vector
memberv.Length = length
// Re-scale the vector by a constant
memberv.Scale(k) = Vector2D(k*dx, k*dy)

// Types: interfaces
// —————————————————————

typeIPeekPoke =
abstractPeek: unit->int
abstractPoke: int->unit
// Types: classes with interface implementations
// —————————————————————

/// A widget which counts the number of times it is poked
typeWidget(initialState:int) =
/// The internal state of the Widget
let mutablestate = initialState

// Implement the IPeekPoke interface
interfaceIPeekPoke with
memberx.Poke(n) = state <- state + n
memberx.Peek() = state

/// Has the Widget been poked?
memberx.HasBeenPoked = (state <> 0)

letwidget = Widget(12) :> IPeekPoke

widget.Poke(4)
letpeekResult = widget.Peek()
// Printing
// —————————————————————

// Print an integer
printfn “peekResult = %d”peekResult

// Print a result using %A for generic printing
printfn “listC = %A”listC

Related Posts