The post I wrote for GreenShot used a configuration file to tell the app to use the CLR and .NET FX that is already installed on Windows 8. The same hack works for the Metro UI Tweaker tool from The Windows Club (which I found via winsupersite.com).
So grab the configuration file I used for GreenShot but this time name it "Metro UI Tweaker.exe.config".
-
How to run Greenshot on .NET 4.5 (Windows 8). Greenshot is an OSS alternative for SnagIt (screenshot tool).
Don't install the Greenshot installer. It will refuse to install without .NET 2.0, even though it seems to run fine on .NET 4.5.
1) download the zip file and extract it to C:\Program Files\Greenshot.
Note: On Win8 you'll need to be running a process with Admin privileges to create the directory and extract the files.
2) create Greenshot.exe.config to tell .NET to run Greenshot on .NET 4 with a couple of compatibility options. https://gist.github.com/1223509
0Add a comment
-
I'm thinking about how to take some of the middle-tier parallel concepts like #RxNet and apply them in a little OSS GUI app I've been thinking about. I quickly found this gem, ReactiveUI PDF . A couple of quotes that stoked my interest:
"What’s in this library
ReactiveCommand - an implementation of ICommand that is also a Subject whose OnNext is raised when Execute is executed. Its CanExecute can also be defined by an IObservable which means the UI will instantly update instead of implementations which rely on RequerySuggested."
...
"Some philosophy
A lot of examples of the Reactive Extensions make its domain appear really constrained, like the only thing it’s ever useful for is either handing web service requests and implementing drag-and-drop. However, here’s the key thing to realize - a property change notification is an event.Once you realize that Reactive Programming applies to any time an object changes state, Rx suddenly becomes far more applicable to any programming domain - really, Rx is a library to model state machines that are context-free with respect to threading."
And, I can use all the high-level composition that I've been using in the middle tier. Like Merge() to join streams of events, and Throttle() to do in one line that takes a half-page of code with other frameworks. This looks promising. One glitch. The author of the library recently moved from Microsoft (Office team) to GitHub. Uh-Oh. But too promising to ignore it. At least I hope he still works in C#, maybe he can help with the Windows OSS clients, like Git Extensions, which is written in C# (but not hosted on github).
nRoute is another MVVM framework that leans on Rx for event streams. It's author is French. Hmm.
It's good to have choices, unlike 18 months ago.
0Add a comment
-
I was thinking about how to rewrite an old (2009) WCF middle-tier service, and have been thinking about George Tsiokos's recent TPL vs. RxNet post.
I think a middle-tier service is perfect to illustrate how I see the strengths and weaknesses of these two. Specifically the scenario:
Complex Middle-Tier: Startup vs. Message Handling
TPL might be great for startup tasks. There is one 'global' task, Initialize, that has many sequences and chunks (in TPL these could be child tasks) that can have different degrees of parallelization. It also requires global 'command and control' and 'top-down' composition and error handling (a type of event correlation). If any critical part of startup fails then tear-down the service (cancel outstanding parallel tasks) and exit the service quickly. So global handling and command-control programming style (root of the call hierarchy has all control).
Once everything is initialized you want bottom-up event correlation and error handling. The function at the top of the callstack has no control (usually a WCF operation or I/O completion callback). You only want global state to be touched when absolutely necessary, not touched by ignorable infrastructure errors, and not by errors that are ignorable according to business rules.
Startup, large complex top-down composable work:
TPL
Streams, composable business logic (streams that include error/end):
RxNet
With .NET 5 the TPL dataflow libraries might change things again, but for now I much prefer RxNet for composing and routing 'messages' between layers. We recently used it in a project and when you have to correctly handle error scenarios it shines. Imagine a WCF callback for a business operation that is completely async, where business logic has to fire if the notification fails (delivery of the data to the client). The code isn't pretty in either case, but is better and can be handled at the right level of the lego blocks with RxNet.0Add a comment
Add a comment