AntonioPelleriti.it [aka z9]

I code, therefore I am

NAVIGATION - SEARCH

Storia delle versioni di C#

Mi capita spesso di ricercare in quale versione di C# è stata introdotta una certa funzionalità, o al contrario, voler capire quali sono le novità introdotte in una data versione.

Una mia storia delle versioni di C# è naturalmente presente nelle varie edizioni del mio libro "Programmare con C#" (al momento la più recente è la versione su C# 7).

Nell'attesa di lavorare ad una nuova edizione, mi tengo naturalmente al passo con i tempi, e soprattutto per sfruttare le migliorie apportate al linguaggio, ad ogni nuova release, presente e futura, vado a cercare queste nuove funzioni.

Nella repository GitHub ufficiale del linguaggio C#, sono presenti tutti i documenti di progetto, sia quelli passati, che le nuove proposte per il futuro. 

Inoltre la pagina Features Added in C# Language Versions riassume tutte le versioni, con relative funzionalità introdotte e versione di Visual Studio che le comprende.

Ad oggi (giugno 2018) l'elenco delle versioni di C# parte dalla 1.0 e arriva alla 7.3, ed è riassunta qui di seguito:

 

C# 1.0 (Visual Studio.NET)

Classes

Structs

Interfaces

Events

Properties

Delegates

Expressions

Statements

Attributes

Literals

 

C# 2 (VS 2005)

Generics

Partial types

Anonymous methods

Iterators

Nullable types

Getter/setter separate accessibility

Method group conversions (delegates)

Static classes

Delegate inference

 

C# 3 (VS 2008)

Implicitly typed local variables

Object and collection initializers

Auto-Implemented properties

Anonymous types

Extension methods

Query expressions

Lambda expression

Expression trees

Partial methods

 

C# 4 (VS 2010)

Dynamic binding

Named and optional arguments

Co- and Contra-variance for generic delegates and interfaces

Embedded interop types ("NoPIA")

 

C# 5 (VS 2012)

Asynchronous methods

Caller info attributes

 

C# 6 (VS 2015)

Draft Specification online

Compiler-as-a-service (Roslyn)

Import of static type members into namespace

Exception filters

Await in catch/finally blocks

Auto property initializers

Default values for getter-only properties

Expression-bodied members

Null propagator (null-conditional operator, succinct null checking)

String interpolation

nameof operator

Dictionary initializer

 

C# 7.0 (Visual Studio 2017)

Out variables

Pattern matching

Tuples

Deconstruction

Discards

Local Functions

Binary Literals

Digit Separators

Ref returns and locals

Generalized async return types

More expression-bodied members

Throw expressions

 

C# 7.1 (Visual Studio 2017 version 15.3)

Async main

Default expressions

Reference assemblies

Inferred tuple element names

Pattern-matching with generics

 

C# 7.2 (Visual Studio 2017 version 15.5)

Span and ref-like types

In parameters and readonly references

Ref conditional

Non-trailing named arguments

Private protected accessibility

Digit separator after base specifier

 

C# 7.3 (Visual Studio 2017 version 15.7)

System.Enum, System.Delegate and unmanaged constraints.

Ref local re-assignment: Ref locals and ref parameters can now be reassigned with the ref assignment operator (= ref).

Stackalloc initializers: Stack-allocated arrays can now be initialized, e.g. Span<int> x = stackalloc[] { 1, 2, 3 };.

Indexing movable fixed buffers: Fixed buffers can be indexed into without first being pinned.

Custom fixed statement: Types that implement a suitable GetPinnableReference can be used in a fixed statement.

Improved overload candidates: Some overload resolution candidates can be ruled out early, thus reducing ambiguities.

Expression variables in initializers and queries: Expression variables like out var and pattern variables are allowed in field initializers, constructor initializers and LINQ queries.

Tuple comparison: Tuples can now be compared with == and !=.

Attributes on backing fields: Allows [field: …] attributes on an auto-implemented property to target its backing field.

 

N.B. 

nella repository è presente anche il documento delle proposte che potrebbero vedere la luce con la versione C# 8!

Programmare con C# 6: in arrivo

Finita la seconda rilettura delle bozze, iniziatala la fase di impaginazione e di impostazione grafica, non manca molto all'uscita in libreria di

Programmare con C# 6, guida completa

Non ho ancora una data di uscita certa, o altri dettagli, come il numero di pagine definitivo, o se qualche capitolo verrà escluso (e magari rilasciato su questo sito in pdf!).

Il libro copretutte le novità introdotte da C# 6, in modo completo ed in modo da rendere il testo il riferimento principale in lingua italiana sul linguaggio C#: l'obiettivo, come per la prima edizione, è stato quello di scrivere il miglior libro italiano su C# 6 (scusate la presuzione!).

Nell'attesa di aggiornarvi con maggiori dettagli di seguito l'elenco degli argomenti che è quasi definitivo.

  • 1. C# e la piattaforma .NET
  • 2. Concetti di base di C#
  • 3 Tipi e oggetti
  • 4 Espressioni e operatori
  • 5 Controllo di flusso
  • 6 Programmazione a oggetti in C#
  • 7 Ereditarietà e polimorfismo
  • 8 Gestione delle eccezioni
  • 9 Tipi generici e collezioni
  • 10 Delegate ed eventi
  • 11 LINQ
  • 12 Multithreading, Programmazione asincrona e parallela
  • 13 XML in C#
  • 14 Reflection, attributi e programmazione dinamica
  • 15 Accesso ai dati
  • 16 .NET Compiler Platform
  • 17 Applicazioni pratiche di C#
  • App. A Stringhe ed espressioni regolari
  • App. B Interoperabilità
  • App. C Risposte alle domande

Noterete la presenza di un nuovo capitolo, il 16, dedicato interamente ad una delle principali nuove funzionalità o caratteristiche di .NET e C# 6: cioè la .NET Compiler Platform, ed inoltre una appendice con le risposte alle domande poste alla fine di ogni capitolo.

 

Inglobare tutte le dll in un singolo exe e utilizzarle con la Reflection

La stragrande maggioranza delle applicazioni usa delle dll esterne, eventualmente di terze parti.

Quando l'applicazione deve essere distribuita anche gli assembly da cui dipende, cioè tutti i riferimenti esterni devono essere distribuiti assieme all'eseguibile. In generale lo si fa con la classica tecnica Xcopy, prendendo tutto quello che c'è nella cartella Bin/Release prodotta da Visual Studio per esempio, oppure creando un setup ad hoc che si occupi di tutto.

Un'altra possibile tecnica è quella di inglobare tutte le dll all'interno dell'eseguibile e quindi con la comodità di distribuire un solo file.

Supponiamo di avere una semplice applicazione Windows Forms, che utilizza una dll per esempio chiamata MyAssembly.dll.

Al progetto Windows Forms, che avrà un riferimento alla libreria, bisogna apportare una prima modifica, aggiungendo il file MyAssembly.dll come un normale file (click con il destro, Add Existing Item e selezione della dll) e quindi, fra le proprietà del file aggiunto, impostando il valore della proprietà Build Action a Embedded Resource.

A questo punto compilando l'applicazione, l'eseguibile prodotto conterrà la dll come risorsa inglobata. Potete verificarlo con un decompilatore come Reflector o JustDecompile.

 

 

Adesso bisogna fare in modo che a runtime l'applicazione sia in grado di recuperare la dll dalle risorse embedded.

Nel metodo Main dell'applicazione aggiungiamo un gestore dell'evento AssemblyResolve dell'AppDomain corrente:

 static void Main()
 {
            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
...

 

Il gestore dell'evento, si occupa di ricercare fra le risorse embedded l'assembly (l'evento si scatena al primo utilizzo dell'assembly riferito) e di restituirlo leggendone il contenuto e caricandolo con il metodo Assembly.Load:

private static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
        {
            string dllName = new AssemblyName(args.Name).Name + ".dll";

            var asm = Assembly.GetExecutingAssembly();
            String resourceName = asm.GetManifestResourceNames().FirstOrDefault(rn => rn.EndsWith(dllName));
            if (resourceName == null) return null; // Non trovata

            using (var stream = asm.GetManifestResourceStream(resourceName))
            {
                Byte[] assemblyData = new Byte[stream.Length];
                stream.Read(assemblyData, 0, assemblyData.Length);
                return Assembly.Load(assemblyData);
            }
        }

 

 


 

Guest Post su MSDN Italia: Caller Info Attributes in C# 5

Vi segnalo il mio guest post sui blog di MSDN Italia, dedicato ai Caller Info Attributes di C# 5.0,

dal titolo

Ottenere informazioni sul chiamante di un metodo in C# 5

Il link è il seguente: http://blogs.msdn.com/b/italy/archive/2014/11/27/guest-post-ottenere-informazioni-sul-chiamante-di-un-metodo-in-c-5.aspx


Anteprima C# 6, le slide

Vi segnalo che ho pubblicato su slideshare le slide relative alla sessione dedicata alle  Novità di C# 6, tenuta la Microsoft Mobile Camp di Catania, il 13 novembre 2014.

Clicca il seguente link


Microsoft Mobile Camp: 13 novembre a Catania con OrangeDotNet

Lo usergroup OrangeDotNet in collaborazione con Microsoft, il DMI dell'università di Catania e il WCAP Catania, organizza a Catania il Mobile Camp, due giornate formative gratuite.

Nella prima giornata del 13 novembre conosceremo le novità del mondo .NET che stanno per arrivare nei prossimi mesi e quelle già disponibili per gli sviluppatori.

Personalmente terrò una sessione che mostrerà le novità future di C# 6.0.

Nella giornata del 14 novembre, ospitata dal WCAP Catania ci sarà invece la possibilità di mettere in pratica attraverso un laboratorio di sviluppo libero, le proprie conoscenze.

La registrazione è obbligatoria per entrambe le giornate, e visto che a tre settimane dall'evento le persone registrate sono già tantissime, registratevi subito al seguente link:

 agenda e registrazione

ulteriori informazioni e l'agenda dell'evento sono disponibili qui: http://www.orangedotnet.org/Eventi/Mobile-Camp-2014

 

#3 - ITA | Quante e quali sono le parole chiave di C#?

Quante e quali sono le keyword (o parole chiave) che costituiscono il vocabolario del linguaggio C#, secondo le specifiche 5.0?
Esattamente 77, riportate qui di seguito.

abstract
as
base
bool
break
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
do
double
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
goto
if
implicit
in
int
interface
internal
is
lock
long
namespace
new
null
object
operator
out
override
params
private
protected
public
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
virtual
void
volatile
while

 

questo e altro all'interno di Programmare con C# 5, guida completa


Storia delle versioni di .NET, C# e Visual Studio.

Microsoft ha parlato per la prima volta della nuova piattaforma .NET, originariamente conosciuta come NGWS (Next Generation Web Services) alla conferenza PDC dell'11 luglio 2000. rilasciando una agli sviluppatori una Tech Preview.

La prima Beta 1 di .NET 1.0, vede invece la luce l'1 novembre 2000, seguita da una Beta 2 il 20/06/2001. 

Nella seguente tabelle sono riassunte le successive release della piattaforma .NET, delle specifiche di C# e dell'IDE Visual Studio.

Anno  .NET Framework C# Visual Studio
2002 1.0 1.0 Visual Studio .NET 2002
2003 1.1 1.2 Visual Studio .NET 2003
2005 2.0 2.0 Visual Studio 2005
2006 3.0 2.0
2007 3.5 3.0 Visual Studio 2008
2010 4.0 4.0 Visual Studio 2010
2012 4.5 5.0 Visual Studio 2012
2013 4.5.1 5.0 Visual Studio 2013

Storia delle versioni di .NET, C# e Visual Studio.

.NET Framework Versions, C# Releases, Visual Studio Editions history

 

L'operatore di Null Coalescing in C#

L'operatore ?? è detto operatore di null coalescing, ed è molto utile in una serie di situazioni permettendo di scrivere codice più elegante e ristretto in C#.

Quante volte vi è capitato di dover scrivere un blocco if per controllare se una variabile è null, ed agire di conseguenza scegliendo un valore di default da assegnare alla stessa variabile? Ecco un esempio:

string name;
if(str!=null)
{
 name=str;
}
else name="senza nome";

 

Probabilmente starete pensando: "beh c'è sempre l'operatore ternario!", ed in effetti un altro modo di scrivere lo stesso blocco di codice può essere il seguente:

string name= (str!=null) ? str: "senza titolo";

Ma l'operatore di null coalescing, introdotto già con le specifiche 2.0 ma spesso ignorato da chi si avvicina al mondo della programmazione in C#, consente di essere ancora più concisi.

Esso verifica se l'operando a sinistra è diverso da null, ed in tal caso restituisce il valore dell'operando sinistro stesso. In caso contrario invece restituisce l'operando destro:

string name= str ?? "senza titolo";

L'operatore funziona anche con tipi valore, per esempio nel caso seguente, se il valore della variabile nullableInt è null, viene assegnato alla variabile i il valore 1:

int? nullableInt=null;
int i= nullableInt ?? 1; // i vale 1

 

Se invece nullableInt possiede un valore, esso viene assegnato alla variabile:

int? nullableInt=123;
int i= nullableInt ?? 1;  // i vale ora 123