Written and maintained by the same author of the Eve Framework itself, Eve.NET is delivered as a portable library (PCL) and runs seamlessly on .NET4, Mono, Xamarin.iOS, Xamarin.Android, Windows Phone 8 and Windows 8. We use Eve.NET internally to power our iOS, Web and Windows applications.

And now please forgive me while I take you on a quick motivational, strongly opinionated, probably boring and overzealous detour

Python and C# Motherfucker, Do You Speak It? *

If you don’t then well, you should consider doing just that. Especially so these days, with C# and the whole .NET platform going open source and cross platform. Actually, thanks to technologies like Mono and Xamarin (also based on Mono) we have been able to run C# code on all major platforms for a while: iOS, Android, OSX, Linux, Windows, Windows Phone, you-name-it. And what’s even better, on mobile platforms C# is compiled to native so performance is a non-issue.

What makes C# a perfect match for a REST API is precisely that: it’s ubiquity. You can have a portable client library like Eve.NET which runs seamlessly (and untouched) on all these mobile desktop and server platforms.

If you already have a Web Service running on Eve and are now looking at the client side of things then well, you should consider C# and Eve.NET because you know, you can’t have a native iOS app written in Python anyway. On the other hand if you are a C#/.NET shop consider this: you can have a powerful Web Service up and running in minutes (even if you don’t grok Python yet – trust me on that) and a complete out-of-the-box, cross platform client library ready to go with it.

A few years ago I gave a talk about leaving my Comfort Zone (**) and getting out of my .NET nest. That opened the path to Python, MongoDB, Node and so many other technologies and best practices and, what’s even more relevant, most of what I learned down that path I ended up using in my .NET projects in the long run. But the point I’m trying to make is don’t be afraid of change, it can only improve your skills making you a better all-around professional programmer.

Never mind the naysayers. Polyglot is the way.

(*) I’m paraphrasing Zed A. Shaw’s Programming, Motherfucker. You should get a T-Shirt by the way. They are so cool.

(**) Since then there have been plenty of talks on the same subject. Mine was an 5 minutes ignite talk and was in Italian, so you probably don’t care (it’s on my Talks page anyway).

Back to business now.

Usage

Initialization is as simple as instantiating a new client and providing it with the web service entry point.

// Initialize and set API address.
var client = new EveClient();
client.BaseAddress = new Uri("http://api.com");

// Set target resource for subsequent requests.
client.ResourceName = "companies";

Getting a list of objects is pretty straightforward:

// List<T>
companies = await client.GetAsync<Company>();

// Objects changed since DateTime.
var ifModifiedSince = DateTime.Now.AddDays(-1);
companies = await 
  client.GetAsync<Company>(ifModifiedSince);

// Refresh an object
company = await client.GetAsync<Company>(company);

// Raw, conditional GET request
var companyId = "507c7f79bcf86cd7994f6c0e";
var eTag = "7776cdb01f44354af8bfa4db0c56eebcb1378975";

company = await 
  client.GetAsync<Company>("companies", companyId, eTag);

Other CRUD operations are easy too:

// Create (POST)
company = await 
  client.PostAsync<Company>(
    new Company { Name = "MyCompany" }
  );

// Update (PUT)
company.Name = "YourCompany";
var result = await client.PutAsync<Company>(company);

// Delete (DELETE)
var result = await client.DeleteAsync(company);

As you can see all methods are Async and return full object instances parsing JSON in and out on for you. If you need more control you can query the HttpResponse property to inspect the original JSON, response headers, status code, etc.

Behind the scenes data integrity and concurrency control are transparently handled so for example PutAsync performs a If-Match check and same happens with DeleteAsync. On PostAsync new objects are returned with fresh meta-fields such as ETag, DateCreated, DateUpdated and UniqueId. Mapping object properties to JSON fields and Eve metafields is just a matter of setting the JSonPropertyAttribute and RemoteAttribute:

public abstract class BaseClass
{
  [JsonProperty("_id")]
  [Remote(Meta.DocumentId)]
  public string UniqueId { get; set; }

  [JsonProperty("_etag")]
  [Remote(Meta.ETag)]
  public string ETag { get; set; }

  [JsonProperty("_updated")]
  [Remote(Meta.LastUpdated)]
  public DateTime Updated { get; set; }

  [JsonProperty("_created")]
  [Remote(Meta.DateCreated)]
  public DateTime Created { get; set; }   
}

public class Company : BaseClass
{
  [JsonProperty("n")]
  public string Name { get; set; }

  [JsonProperty("p")]
  public string Password { get; set; }
}

For a complete list of usage examples see the README

Current Status and License

Eve.NET is a Nicola Iarocci and Gestionali Amica open source project distributed under the BSD license. It is a work in progress but it’s pretty stable already. It is available on NuGet as a pre-release package. The test suite can be run against a local Eve instance or, if you don’t grok Python yet, you can use a free test instance which is available online, see the README for details.

Did you read this far? Well thank you! And please, consider showing your appreciation by starring the project on GitHub. It feels so lonely out there.

If you want to get in touch, I’m @nicolaiarocci on Twitter.

This is the problem with emphasizing computer science over learning to code. Without an understanding of what’s happening at a low level, my peers ran into issues […] and had no idea what to do to debug them. This is a problem that stems from teaching people computer science but not teaching them how to code. Learning to code isn’t just teaching people how to spell – it’s teaching people the meaning behind the words.

via Learn C, Then Learn Computer Science

This article attempts to give a sort of ‘orientation tour’ for people whose previous programming background is in high (ish) level languages such as Java or Python, and who now find that they need or want to learn C.

via The Descent to C.

C came into being in the years 1969-1973, in parallel with the early development of the Unix operating system; the most creative period occurred during 1972. Another spate of changes peaked between 1977 and 1979, when portability of the Unix system was being demonstrated. In the middle of this second period, the first widely available description of the language appeared: The C Programming Language, often called the `white book’ or `K&R’ [Kernighan 78].

via Chistory.

Il linguaggio C# dispone da sempre di una soluzione elegante al problema della gestione degli eventi: il delegato EventHandler. Events è una mia implementazione Python del EventHandler C#. In pratica si tratta di una classe molto leggera che incapsula il cuore del meccanismo di sottoscrizione e gestione degli eventi, e tenta di farlo in maniera “naturale”, sembrando parte integrante del linguaggio Python.

Come usare Events

Tecnicamente un evento è qualcosa a cui è possibile “attaccare” una o più funzioni di callback. Prima di tutto creiamo una funzione di callback che verrà invocata allo scatenarsi dell’evento a cui siamo interessati:

Poi ‘iscriviamo’ la nostra funzione all’evento:

Notate come l’evento sia al tempo stesso dichiarato e sottoscritto, in un’unico passaggio. Più funzioni possono sottoscrivere lo stesso evento. Quando si scatena un evento tutte le funzioni ad esso collegate vengono invocate in sequenza. Per scatenare l’evento ci basta eseguire una chiamata all’evento stesso:

Un esempio di modello Model-View-Controller

In genere nell’implementazione di uno schema MVC l’istanza della classe Events farà parte di un Modello, come in questo esempio:

Oggetti View e Controller ne sono i tipici  sottoscrittori:

E’ inoltre possibile vincolare il nome degli eventi e fare l’introspezione delle sole due classi che costituiscono Events. La documentazione include gli esempi e le istruzioni per l’installazione; il codice sorgente è a disposizione su GitHub. Buon divertimento!

Today, we are unveiling significant language and framework enhancements in C# and Visual Basic that enable developers to harness asynchrony, letting them retain the control flow from their synchronous code while developing responsive user interfaces and scalable web applications with greater ease.   This CTP delivers a lightweight asynchronous development experience as close to the standard synchronous paradigms as possible, while providing an easy on-ramp to the world of concurrency

Lo stesso Somasegar riconosce che finora sviluppare applicazioni asincrone complesse con la piattaforma .NET non è stato facile. Tempo fa l’ho sperimentato in prima persona. Lavoravo su Amica Prodigy Backup, una applicazione di backup remoto.

Il programma invia files di grandi dimensioni al servizio di cloud storage S3 aggiornando l’interfaccia utente con lo stato del trasferimento e consentendo nel frattempo di operare liberamente con l’interfaccia. Devo ammettere che si è trattata di una sfida molto accattivante. Lavoravo per la prima volta su sistemi cloud e c’era molto da imparare. La parte più difficile fu naturalmente la gestione dei processi asincroni sul client, che era una applicazione WinForm scritta su .NET Framework.

Una rapida occhiata al codice di esempio presente nell’articolo di Somasegar è meglio di mille parole. ‘The Old Way’ vs ‘The New Way’ ha un vincitore evidente, ed è la New Way. Mi piace molto il concetto della nuova keyword Await, è una soluzione così elegante! Come sempre in questi casi occorrerà scendere nei dettagli per verificare l’affidabilità di questa nuova soluzione.

La  CTP è già disponibile per il download, attualmente solo per le versioni inglesi di Visual Studio 2010.