Arik Poznanski's Blog : C#

I’m a Microsoft MVP!

arik — Sun, 02 Oct 2011 22:25:00 GMT

I've recently received an email from Microsoft notifying me I've been awarded Microsoft MVP in Visual C# !

I’d like to thank Microsoft and specifically Guy Burstein for his guidance and excellent advice on finding ways to help the developers community.
Also, a special thanks is in order for my managers at Sela Group: David Bassa, Caro Segal and Ishai Ram for giving me the time to invest in the developers community.
Lastly, I'd like to thank you, my blog readers.

Now that I got this out, I can continue my Thailand honeymoon trip :)

That's it for now,
Arik Poznanski.

Windows 8: What's New?

arik — Mon, 19 Sep 2011 04:24:04 GMT

Got back from Build conference. Since I expect many people will ask me "So, what's new?" and since the answer is rather complex, I figured I should try to write a post about it, so here goes…

General Information

Windows 7 sold (i.e. legal copies) over 450,000,000 copies since it was released.
Windows 7 bypassed Windows XP in world usage.
Windows 8 will be used primary for tablets and other touch-based devices.
Windows 8 can run on Intel-based processors or ARM-based processors.
Windows 8 consumes fewer resources than Windows 7 and has the same hardware requirements.
Windows 8 has a new user interface, used primarily with touch screens but supports fallback to mouse and keyboard, applications that uses the new user interface are called "Metro-style applications".
All participants of the Build conference received a Samsung tablet with a preview release of Windows 8, that has the following spec:
- Intel Core i5
- 4GB DDR3
- 64GB SSD
- 11.6" diagonal, 1366x768 display
- Included dock and USB keyboard
Windows 8 Developer Preview version can be downloaded here.

Windows 8 for Developers

There is a new way to expose Windows API named Windows Runtime or WinRT.
- WinRT is completely native and is built above COM with the addition of inheritance, generics, delegates and more. Basically WinRT = Modern COM.
- WinRT doesn't cover all previous Win32 APIs.
- WinRT has can be used from C++, C#, VB.NET and JavaScript using language projections which are auto-generated from the WinRT APIs and provide a natural and familiar experience for developers of the language.
- WinRT API follow a guideline that says that every API which might take more than 50ms should be async. As a result a lot of WinRT APIs are async.

WinRT includes a native UI framework, XAML-based, for building Metro-style applications.
The XAML of the new WinRT UI framework resembles Silverlight XAML rather than WPF XAML.
Metro-style applications can be built in the following technologies:
- C++ and XAML
- C# and XAML
- VB.NET and XAML
- JavaScript and HTML/CSS
A Metro-style application can collaborate with another Metro-style application without knowing him at all using several contracts that Windows 8 defines, e.g. share source contract and share target contract.
Metro-style applications should define the capabilities they use, similar to Windows Phone applications. At runtime these declarations are enforced.
C++ has new extensions that allows easy integration with WinRT, these extensions follow a syntax similar to C++/CLI, only they are completely native.
The next version of .NET Framework is 4.5, nothing too exciting there.

IDE Improvements

There is a preview version Visual Studio 11 and Expression Blend 5.
New in Visual Studio 11:
- Added new project templates for developing Metro-style applications in all the supported languages.
- Productivity Power Tools incorporated into Visual Studio 11.
- New features for agile development including: Sprint Planning, Managing Task Board, Performing Code Reviews.
- XAML properties editor is the same as the corresponding Blend editor.
- Deploy to the new Windows App Store directly from Visual Studio 11.
- Added tools for viewing and basic editing 3D models, images, textures and also for debugging DirectX based output.
- Added feature that allows searching for code duplication based on semantic tree instead of simple text search.
New in Expression Blend 5:
- Designing Metro-style HTML / CSS applications.
TFS will be available as a service on the cloud.

Some General Insights:

C++ is very much alive! I've been to an excellent lecture on modern C++ (the portable one, not MS specific), by Herb Sutter. Wow. So many C++ developers, the room was packed!
Future of Silverlight is not clear. There will be version 5 but there's no information about what's next.

Since all the videos are now available on the conference site, I strongly suggest you see the ones that are interesting for you. Note that there quite a lot.

That's it for now,
Arik Poznanski.

New C# Forum for the Israeli Developers Community

arik — Thu, 18 Aug 2011 03:48:01 GMT

Following are some blog news:

New Israeli C# Forum

I'm proud to present a new MSDN forum in Hebrew for the C# developers community in Israel, managed by yours truly.

The forum is available on the following link: http://social.msdn.microsoft.com/Forums/he-il/VisualCsharpil

To all those nice developers who keep asking me C# related questions by mail, I strongly urge you to post your C# related questions on this forum.

NOT because I don't enjoy it!

On contrary, I love to help you and would even more enjoy it if even more people could enjoy the answers. Plus, there's more people on this forum that can help, so you will probably get an answer sooner :)

In other news..

New Windows 8 Blog

With Build conference approaching fast, Microsoft recently opened a new blog for Windows 8 behind the scenes details. Hopefully this is a sign that Microsoft is going to raise the curtain from the mysterious Windows 8. Follow the new blog here or on their Twitter @BuildWindows8.

That's it for now,
Arik Poznanski.

Using Windows Phone As Windows 7 Accelerometer Sensor

arik — Sat, 13 Aug 2011 15:54:20 GMT

I just had a cool idea! (actually I had it like 6 month ago, but bear with me).

My idea involves mixing some of the features in Windows 7 with some of the features in Windows Phone 7, to create a glorious mix!

Windows 7

One of the new features in Windows 7 is the Sensor API which provides a standard interface for accessing sensors of various types, like accelerometer, etc..

I wrote in the past about how you can consume this API from a C# application using Windows API Code Pack.

Windows Phone 7

Windows Phone 7 comes with a few sensors out of the box, among them: accelerometer!

Idea

What if we use Windows Phone 7 accelerometer sensor as a standard device on Windows 7?

Roadmap

So how can we accomplish that? let's break the idea to steps:

Step 1: Create a software driver

I’ll start with creating a dummy software driver. This driver will implement what's necessary to be a standard Windows 7 Accelerometer sensor, but at this stage will simply return constant data.

In order to write a sensor driver for Windows 7 I’ll need to use User Mode Driver Framework (UMDF), a COM-like, C++ framework for writing user-mode drivers in Windows 7.

Step 2: Transfer Windows Phone 7 sensor data into the PC

The next step is to find a way to transfer the accelerometer data from a Windows Phone device into the PC. One possible way of doing this implementing a local WCF service on the desktop that the Phone will keep calling with accelerometer data. This will require an application to run on the phone to keep the data flowing.

Step 3: Consume the WCF service from the phone

Using the service from the previous step we can now consume it in a simple Windows Phone application that all it does is getting the accelerometer sensor data using the phone API and call the WCF service with the latest data.

Step 4: Make the software driver consume the Windows Phone 7 data

Now that I have a software driver that returns dummy accelerometer data and a way to get real accelerometer data from the Windows Phone, all I need to do is connecting the dots and make my accelerometer driver return the real data. To do this I'll need some kind of inter process communication to transfer the data from the WCF service to the driver.

Long Story Short…

I present to you the Windows Phone Accelerometer Driver for Windows 7!

The full source code for this project can be found on the CodePlex project site.

Some Implementation Details

The actual driver was fairly easy to implement since I used the CodeProject article "Writing a Sensor Driver for the Wiimote on Windows 7" by Rajasekharan Vengalil as a base for my Windows Phone 7 driver. You can find the driver source code in the project named WP7AccelerometerDriver.

As mentioned earlier I've implemented a simple local WCF service for transferring the accelerometer data from the phone to the driver. You can find the service source code in the project named WP7AccelerometerService. The service uses named pipes to communicate with the driver.

The phone application is a very simple one that consumes the WCF service and call it whenever a new accelerometer value is available. You can find its source code in the project named WP7AccelerometerClient.

Finally, if you want to check the functionality of the accelerometer driver you can use either the SensorDiagnostics project or the more fun PlaneDemo project, which I borrowed for Sergey Zwezdin blog.

How to Install?

1. Download and extract project binaries or source from the CodePlex project site.

2. Open CMD as administrator

3. Go to the folder \Driver\Install\

4. According to the bitness of your OS Run install_wp7_driver_32bit.bat or install_wp7_driver_64bit.bat to install the driver.

5. When the following notification appears, select "Install this driver software anyway":

This should take around 1-2 minutes to complete.

6. Enable installed Sensor in the Control Panel

7. Run the WCF service from as administrator. If you run it from Visual Studio, make sure you ran Visual Studio as administrator.

8. Run the Windows Phone client on a real device while connected to the PC and enter your PC (LAN) IP

9. That's it! you can now sit back and enjoy the ride using the PlaneDemo application or SensorDiagnostics, or any other software that uses the accelerometer sensor.

How to Uninstall?

If you want to uninstall the driver simply go to the Device Manager, select the "WP7 Accelerometer Sensor" device from the Sensors category, select uninstall from the context menu and make sure you mark the checkbox to delete the driver.

Final Note

I've seen the project works both on a real device and using the phone emulator, however it's not a one-click install. I expect users to have problems with the installation. If you encounter some problems, please post on the CodePlex project site forum page and I'll do my best to help.

Also, if you want to improve the source code (maybe adding GPS support?) or the installation procedure, I'll be happy to include your improvements and even include you as one of the project members on CodePlex.

This project was pure fun since it combines many useful technologies to create real value. Among the technologies you can find: C++, COM, UMDF, C#, WCF, WP7, etc..

That's it for now,
Arik Poznanski.

Spelling and Grammar Checking Plugin for Windows Live Writer

arik — Sat, 11 Jun 2011 02:04:42 GMT

Introduction

In my previous post I’ve presented “After the Deadline”, a spelling and grammar checking web service and my .NET wrapper library. This library allows you to integrate spell and grammar checking in your .NET application. The library was written in C# using .NET 4.

Also, back in this post, I’ve presented how one can use a .NET 4 DLL from a .NET 2 executable.

All of this was just preparations for writing my own grammar checker plugin for Windows Live Writer.

Now, I know what you’re thinking.. “Doesn’t WLW already have a spell checker?”
Answer: it does, but its grammar checking abilities are quite limited.

Obviously, I’ve used my “After the Deadline” wrapper library for the grammar checking. And since Windows Live Writer plugins must be written in .NET 2, I’ve used the same techniques mentioned in my previous article mentioned above.

Where can I get this awesome plugin?

Well, both the source code and an MSI installer can be downloaded from the downloads section in the new CodePlex project I’ve created.

Using the spelling and grammar checker plugin

Step 1: Select the text you want to check

Step 2: Go to the “Insert” tab and select “Grammar Checker” from the listed plugins

Step 3: Correct the presented errors using the “Spelling and Grammar” dialog

Step 4: Repeat step 3 until a completed message appears

P.S.

Somehow, merely 2 days after I've created the CodePlex project there were three blog posts about it. WOW. I guess this plugin was needed more than I thought.

That’s it for now,
Arik Poznanski.

C# Library for Grammar and Spell Checking

arik — Wed, 08 Jun 2011 20:54:24 GMT

Introduction

I recently had the idea to create a plug-in for Windows Live Writer that will provide grammar checks in addition to the built-in spell checks.

As I’ve showed before, creating plug-ins for Windows Live Writer is easy, the problem was to get the code for doing the grammar checking.

I’ve found this wonderful site named “After the Deadline” that provides a web based API for both grammar and spell checking, free for non-commercial use!

The site also provides several wrapper libraries for using these APIs. Unfortunately, C# (or any other .NET language) is not among them. Until now.

I present you a C# wrapper library for easily using the “After the Deadline” APIs from any .NET application.
I’ve uploaded the C# wrapper to CodePlex and I’ll try to publish it also on the official AtD site.

Features

Check both grammar and spelling of a given document
Check only grammar of a given document (faster)
Get extra information (in HTML format) about specific errors
Get general statistics on a given document

APIs

These previously mentioned features are exposed by the following simple interface:

/// <summary>
 /// Initializes the After the Deadline service
 /// </summary>
 /// <param name="applicationKey">The application key.</param>
 /// <param name="userKey">The user key.</param>
 public static void InitService(string applicationKey, string userKey);
 
 /// <summary>
 /// Checks a document and returns errors and suggestions
 /// </summary>
 /// <param name="data">The data to check</param>
 /// <returns>Enumerable of error objects</returns>
 public static IEnumerable<Error> CheckDocument(string data);
 
 /// <summary>
 /// Checks a document (sans spelling) returns errors and suggestions
 /// </summary>
 /// <param name="data">The data to check</param>
 /// <returns>Enumerable of error objects</returns>
 public static IEnumerable<Error> CheckGrammar(string data);
 
 /// <summary>
 /// Returns HTML describing an error
 /// </summary>
 /// <param name="text">The text that triggered an error</param>
 /// <returns>The HTML response</returns>
 public static string Info(string text);
 
 /// <summary>
 /// Returns statistics about the writing quality of a document
 /// </summary>
 /// <param name="data">The data to check</param>
 public static IEnumerable<Metric> Stats(string data);

The InitService method just sets an application key and user key you should generate according to the following instructions.

The most useful method is CheckDocument which accepts the text to check and returns a collection of error objects.

Since this is simply a wrapper around the original REST API, I strongly suggest you check out the original API documentation to get more details about the parameters and return values.

Can you provide some details about the implementation?

Sure. The API which is exposes by “After the Deadline” site is based on REST and XML responses.

I simply use WebClient’s DownloadString method to get access to the REST interface and then parse the XML using LINQ to XML. Nice and easy.

What's next?

On my next post I'll show you a cool implementation of a plugin for Windows Live Writer that uses this library to provide grammar checking.

That’s it for now,
Arik Poznanski.

How To Use a .NET 4 Based DLL From .NET 2 Based Application?

arik — Mon, 30 May 2011 23:50:01 GMT

Introduction

The official answer is you can’t. Even with the In-Process Side by Side execution (SxS) feature, introduced in .NET 4.

The SxS feature was intended to be used when COM is involved. For example, if you got an application that loads plugins, like outlook, and it loads 2 COM plugins, one is using .NET 4 and the other is using .NET 2.0 then it will load two versions of the CLR into the process using the new SxS feature.

What if I simply have a .NET 2 application or DLL that needs to access a .NET 4 DLL?

Personally I’ve encountered two scenarios when I had to solve this problem:

I had a 3rd-party control that would load only in a .NET 3.5 application, but I had to use it in a .NET 4 application.
I wanted to write a plug-in for Windows Live Writer, which must use .NET 2.0, but I needed to use in my plug-in a .NET 4 DLL.

So, what can we do if no COM is involved?

Well, simply add COM to the mixture..

The idea is that you can expose the required classes from your DLL (which uses .NET Framework X) as COM classes (using COM Interop), and then use those classes from your other DLL (which uses .NET Framework Y). Since you are crossing a COM interface, in-process SxS will kick in and work its magic.

Steps to work around the problem

Create a .NET 4 DLL

Suppose we have a .NET 4 DLL which does some .NET 4 functionality. In the attached example our .NET 4 class prints the CLR version, which should be 4. This DLL is compiled with .NET Framework 4.

using System;
 
 namespace Net4Assembly
 {
     public class MyClass
     {
         public void DoNet4Action()
         {
             Console.WriteLine("CLR version from DLL: {0}", Environment.Version);
         }
     }
 }

Create a .NET 2 EXE

Here we create a .NET 2 EXE which will eventually call the .NET 4 DLL, currently all it does is write it’s own CLR version.

using System;
 
 namespace Net2Assembly
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("CLR version from EXE: {0}", Environment.Version);
         }
     }
 }

Create a .NET 4 to .NET 2 adapter

Here we create a .NET 4 DLL that exposes the same functionality we need from our original .NET 4 DLL only it exposes it in a COM-friendly way. In this example, it only needs to delegate the call to the original implementation, but in more advanced scenarios it should translate the parameters to something more COM friendly. In addition to changing the parameters the classes also implement interfaces (as required by COM) and are marked with ComVisible and Guid attributes to allow access using COM.

Here is our COM visible interface:

using System;
 using System.Runtime.InteropServices;
 
 namespace Net4ToNet2Adapter
 {
     [ComVisible(true)]
     [Guid("E36BBF07-591E-4959-97AE-D439CBA392FB")]
     public interface IMyClassAdapter
     {
         void DoNet4Action();
     }
 }

And our COM visible class, which delegates its calls to the original class.

using System;
 using System.Runtime.InteropServices;
 using Net4Assembly;
 
 namespace Net4ToNet2Adapter
 {
     [ComVisible(true)]
     [Guid("A6574755-925A-4E41-A01B-B6A0EEF72DF0")]
     public class MyClassAdapter : IMyClassAdapter
     {
         private MyClass _myClass = new MyClass();
 
         public void DoNet4Action()
         {
             _myClass.DoNet4Action();
         }
     }
 }

Note: we could have combined Net4Assembly.MyClass and Net4ToNet2Adapter.MyClassAdapter into the same class but I wanted to keep the example general. In real life application you often can’t change the original object and thus you are forced to create a wrapper.

Add support to the adapter for registration-free COM activation

Important note: this part is not really necessary for the .NET 4 to .NET 2 interop to work. But without it you will need to start using he registry for registering your .NET COM components and most projects would rather to avoid it if possible. If this is not a problem just register your objects in the registry and move to the next step.

To add support for registration-free COM we need to create two application manifest files.

The first application manifest specifies dependent assemblies for the client executable. Note that since this manifest replaces the default .NET manifest I’ve added some extra standard manifest stuff (trustinfo), but only the first part is really needed for the registration-free COM to work. To add it, add a file to the client project named app.manifest (“Add new item” –> “Application Manifest”) and change the project properties to use this file.

Following is the content of app.manifest for the Net2Aseembly.exe client in our example:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly
   xmlns="urn:schemas-microsoft-com:asm.v1"
   manifestVersion="1.0">
   <assemblyIdentity
     type = "win32"
     name = "Net2Assembly"
     version = "1.0.0.0"
     />
   <dependency>
     <dependentAssembly>
       <assemblyIdentity
         type="win32"
         name="Net4ToNet2Adapter"
         version="1.0.0.0" />
     </dependentAssembly>
   </dependency>
 
   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
     <security>
       <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
         <!-- UAC Manifest Options
             If you want to change the Windows User Account Control level replace the 
             requestedExecutionLevel node with one of the following.
 
         <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
         <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
         <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
 
             If you want to utilize File and Registry Virtualization for backward 
             compatibility then delete the requestedExecutionLevel node.
         -->
         <requestedExecutionLevel level="asInvoker" uiAccess="false" />
       </requestedPrivileges>
     </security>
   </trustInfo>
 </assembly>

The second application manifest, describes the COM components which are exposed in the assembly. It needs to be set as the application manifest which resides as a native Win32 resource inside the DLL.

Unfortunately, this can’t be done as easily as the previous manifest. In Visual Studio 2010, the relevant field in the project properties is disabled when the project is of type Class Library. So we must go to the Net4ToNet2Adapter.csproj file and change it ourselves. The change is easy, just add the following lines in the relevant place:

<PropertyGroup>
   <ApplicationManifest>app.manifest</ApplicationManifest>
 </PropertyGroup>

Following is the content of app.manifest for the Net4ToNet2Adapter.dll in our example:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <assemblyIdentity
     type="win32"
     name="Net4ToNet2Adapter"
     version="1.0.0.0" />
   <clrClass
     clsid="{A6574755-925A-4E41-A01B-B6A0EEF72DF0}"
     progid="Net4ToNet2Adapter.MyClassAdapter"
     threadingModel="Both"
     name="Net4ToNet2Adapter.MyClassAdapter"
     runtimeVersion="v4.0.30319"
     />
 </assembly>

Use our .NET 4 DLL via COM

Now all you need to do is create an instance of your .NET 4 class from your .NET 2 executable using COM:

using System;
 using Net4ToNet2Adapter;
 
 namespace Net2Assembly
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("CLR version from EXE: {0}", Environment.Version);
             
             Type myClassAdapterType = Type.GetTypeFromProgID("Net4ToNet2Adapter.MyClassAdapter");
             object myClassAdapterInstance = Activator.CreateInstance(myClassAdapterType);
             IMyClassAdapter myClassAdapter = (IMyClassAdapter)myClassAdapterInstance;
             myClassAdapter.DoNet4Action();
         }
     }
 }

Note: Since the interface IMyClassAdapter should be duplicated in the client, I’ve added the source file IMyClassAdapter.cs as a link to the client project.

The result

The result of running this simple console application is:

I think the image speaks for itself.

I’ve uploaded the full source of this example to MSDN Code Gallery.

That’s it for now,
Arik Poznanski.

Sela Haifa Open House: Windows 7 features and Multi-Touch Session – Slide Deck and Demos

arik — Wed, 25 May 2011 02:27:13 GMT

Today (24.05.2011) I’ve delivered two sessions about “Using Windows 7 Features in .NET applications” in Sela Haifa Open House which was presented in Philips building in Haifa.

Dear Philips (and other) developers, I had a great time presenting today's Windows 7 sessions. Thank you for coming!

In the sessions I talked about how to use new Windows 7 features like the new Taskbar, sensors API, the Ribbon control supplied with Windows 7, Application restart and Recovery and plenty of Multi-Touch.
We’ve seen numerous examples, mainly in C++ Win32, WinForms and WPF.

You can download both the presentations and the demos here.

That’s it for now,
Arik Poznanski.

.NET User Group: Windows 7 features and Multi-Touch Session – Slide Deck and Demos

arik — Fri, 20 May 2011 06:22:46 GMT

Yesterday (18.05.2011) I’ve delivered two sessions about “Using Windows 7 Features in .NET applications” in the Israeli .NET User Group, at Microsoft offices in Ra’anana.

I want to thank all the attendees who came to hear the sessions, I truly enjoyed it.

Since we were a little short on time, I couldn’t answer everyone's questions. So if you got an unanswered question, feel free to contact me by mail (find it on my blog left panel) or using the blog contact form.

You can download both the presentations and the demos here.

That’s it for now,
Arik Poznanski.

Coming session: Using Windows 7 Features in .NET Applications, at Sela Haifa in Israel

arik — Sat, 14 May 2011 23:51:06 GMT

In case you missed one of my previous Windows 7 sessions, here is your chance to catch it.

On May 24th I’ll be giving two sessions about “Using Windows 7 Features in .NET Applications”, as part of Sela Haifa Open House.

On the first session “The 7 Show: From XP to Win 7” we will talk about new features in Windows 7 that will modernize your application.
We will learn how to work with the new Taskbar, how to work with Sensors, how to use the Ribbon interface and more.
The session will be rich with examples in .NET, WPF and WinForms.

On the second session “Touch Everywhere” we will see how to use the Multi-touch feature which comes out of the box in Windows 7.
We will learn about the possible level of support (Good, Better & Best) and learn about helper libraries that provide a convenient API when working with multi-touch devices.
The session will include many examples in all the common UI technologies: C++, WinForms, WPF and Silverlight.

The entrance is free, but requires registration.

Hope to see you there!

That’s it for now,
Arik Poznanski.

Coming session: Using Windows 7 Features in .NET Applications, at .NET User Group in Israel

arik — Sun, 08 May 2011 03:54:27 GMT

On May 18th I’ll be giving two sessions about “Using Windows 7 Features in .NET Applications”, as part of the monthly .NET User Group sessions, in Microsoft offices, Ra’anana, Israel.

The entrance is free, but requires registration.

Hope to see you there!

That’s it for now,
Arik Poznanski.

MSDN Event: Windows 7 features and Multi-Touch Session - Slide Deck and Demos

arik — Sat, 09 Apr 2011 21:41:19 GMT

Last Thursday (07.04.2011) I’ve delivered an MSDN session about “Using Windows 7 Features in .NET applications” at Microsoft Ra’anana.

I want to thank all the attendees who came to hear the session, I truly enjoyed it.

In the session I talked about how to use new Windows 7 features like the new Taskbar, sensors API, the Ribbon control supplied with Windows 7, Application restart and Recovery and plenty of Multi-Touch.
We’ve seen numerous examples in C++ Win32, C# WinForms, C# WPF and C# Silverlight.

You can download both the presentations and the demos here.

That’s it for now,
Arik Poznanski.

WPF Single Instance Application – Update

arik — Tue, 05 Apr 2011 03:36:40 GMT

Back in this post I’ve presented some code that make sure you only have one instance of your application.

As I’ve said before, I didn’t wrote this code, I just presented it since I came across it in a Microsoft reference application and didn’t want this gem to remain hidden.

Microsoft recently released a Windows 7 Recipe named “Windows 7 Taskbar Single Instance”, which despite its taskbar-related name is simply a revised implementation of the single instance feature in both .NET and C++. There are well documented samples for both cases. The credit for this recipe goes to Eran Stiller and Yochay Kiriaty.

I advise anyone who needs this feature to work with the new recipe.

That’s it for now,
Arik Poznanski.

Coming session: Using Windows 7 Features in .NET Applications, in Microsoft Israel

arik — Tue, 29 Mar 2011 03:33:43 GMT

Next Thursday, 07.04.2011, I’ll be giving two sessions about “Using Windows 7 Features in .NET Applications”, in Microsoft offices, Ra’anana, Israel.

The entrance is free, but requires registration.

Hope to see you there!

That’s it for now,
Arik Poznanski

Beginner’s Guide for Programming in C# - Hebrew

arik — Mon, 21 Mar 2011 13:29:40 GMT

I've recently published a series of posts in Hebrew on the great site www.webmaster.org.il

The posts can be used as a beginner's guide for programming in C#.

Following are the links for the different posts:

C# Guide - Part 01 – Installation
C# Guide - Part 02 - First Program
C# Guide - Part 03 - Input Output
C# Guide - Part 04 - Basic Variables
C# Guide - Part 05 - Arithmetic Operators
C# Guide - Part 06 - Boolean Operators
C# Guide - Part 07 - Binary Operators
C# Guide - Part 08 - If Statement
C# Guide - Part 09 - Nested If
C# Guide - Part 10 - For Loop
C# Guide - Part 11 - While Loop
C# Guide - Part 12 - Do Loop
C# Guide - Part 13 - Switch Statement
C# Guide - Part 14 - Continue Statement
C# Guide - Part 15 - Nested Loops
C# Guide - Part 16 – Functions
C# Guide - Part 17 - Passing Parameters
C# Guide - Part 18 - Out and Ref Parameters
C# Guide - Part 19 – Arrays
C# Guide - Part 20 - Multi Dimensional Arrays
C# Guide - Part 21 - Foreach Loop
C# Guide - Part 22 – String
C# Guide - Part 23 – DateTime
C# Guide - Part 24 – Enum
C# Guide - Part 25 – Struct

That’s it for now,
Arik Poznanski.