Ultime modifiche in Visual C# 2008

1

Risoluzione dell'overload

L'inferenza dei tipi è ora inclusa nelle matrici dei tipi di puntatore nella risoluzione dell'overload dei metodi.

In Visual C# 2008 e nelle versioni precedenti, l'inferenza dei tipi fa in modo che le matrici dei tipi di puntatore vengano escluse dal processo di risoluzione dell'overload del metodo. Nel codice seguente, il compilatore di Visual C# 2005 seleziona la versione non generica di Test perché la versione generica di Test non viene considerata a causa del parametro di tipo int*[]. In Visual C# 2008, viene selezionata la versione generica di Test.

using System.Collections.Generic;
unsafe class Program
{
    static void Main()
    {
        IEnumerable<int*[]> y = null;
        Test(y); 
    }
// Selected by Visual C# 2008.
    static void Test<S>(IEnumerable<S> x) { } // Selected by Visual C# 2005.
    static void Test(object o) { } 
}

3

Tipi nullable e espressioni ??

A questo punto il compilatore valuta correttamente le espressioni nelle quali le variabili nullable vengono paragonate a se stesse.

Nella versione finale originale di Visual C# 2008, il codice seguente compila e restituisce "false" in fase di esecuzione. In Visual C# 2008 Service Pack 1, viene generato Avviso del compilatore (livello 3) CS1718 e restituito "true".

static class Program
{
    static void Main()
    {
        int? x = null;
        bool y = x == x;
        Console.WriteLine(y);
    }
}

5

Strutture ad albero dell'espressione

Il boxing errato delle espressioni dei metodi nelle strutture ad albero delle espressioni non si verifica più.

Nella versione finale originale di Visual C# 2008, il codice seguente restituisce 7, 0. La riga Console.WriteLine(e.Compile()(default(T))); restituisce zero perché il boxing di S non è stato eseguito correttamente. In Visual C# 2008 SP1, non si verifica alcun boxing e il programma restituisce 7, 7.

using System;
using System.Linq;
using System.Linq.Expressions;
class Program
{
    static void Main()
    {
        Test<S>();
    }
    static void Test<T>() where T : I
    {       
        Expression<Func<T, int>> e = x => x.SetX() + x.X;
// No boxing in SP1:
        Console.WriteLine(e.Compile()(default(T))); 
    }
}
interface I
{
    int X { get; }
    int SetX();
}
struct S : I
{
    public int X { get; private set; }
    public int SetX()
    {
        X = 7;
        return 0;
    }
}

7

Conversioni di tipi

I valori letterali null non sono più convertibili in valori enum.

Nella versione finale originale di Visual C# 2008, i valori letterali null in alcuni casi possono essere convertiti in valori enum. In Visual C# 2008 SP1, Errore del compilatore CS1502 e Errore del compilatore CS1503 vengono prodotti se si tenta di eseguire questa operazione, come mostrato nell'esempio seguente.

enum MyEnum
{
    Zero = 0,
    One = 1
}
class MyClass { }
class Program
{
    static void Main(string[] args)
    {
// Produces CS1502 and CS1503:
        Test((MyClass)null);         }
    static void Test(MyEnum x)
    {
        System.Console.WriteLine(x);
    }
}

9

Attributi

CharSet.Unicode viene ora propagato nei tipi di supporto generati da C# per i campi di matrice fissi.

Il compilatore C# genera i tipi di supporto per incapsulare le matrici fisse. Nella versione finale originale di Visual C# 2008 e nelle versioni precedenti, il layout della matrice è sempre ANSI, anche se l'attributo StructLayout specifica CharSet.Unicode. Non è stato possibile modificarlo in codice sorgente C#. In Visual C# 2008 SP1, a prescindere dal valore CharSet specificato nell'attributo StructLayout viene utilizzato per costruire la classe di supporto, come mostrato nel codice seguente.

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
unsafe struct Test
{
    public fixed char Chars[8];
}
class Program
{
    static void Main(string[] args)
    {
    }
}
Original release version of Visual C# 2008 MSIL:
.class sequential ansi sealed nested public beforefieldinit '<Chars>e__FixedBuffer0'
       extends [mscorlib]System.ValueType
{
  // ... 
} // end of class '<Chars>e__FixedBuffer0'
Visual C# 2008 SP1 MSIL:
.class sequential unicode sealed nested public beforefieldinit '<Chars>e__FixedBuffer0'
       extends [mscorlib]System.ValueType
{
  // . . . 
} // end of class '<Chars>e__FixedBuffer0'

11

Operatori di query standard

Le query sugli insiemi non generici utilizzano la semantica dei cast standard C#.

In espressioni di query LINQ su insiemi non generici ad esempio System.Collections.ArrayList, la clausola from della query viene riscritta dal compilatore per includere una chiamata all'operatore Cast<T>. Cast<T> converte tutti i tipi di elementi nel tipo specificato nella clausola from della query. Inoltre, nella versione finale originale di Visual C# 2008, l'operatore Cast<T> esegue anche alcune conversioni dei tipi di valore e conversioni definite dall'utente. Tuttavia, queste conversioni sono eseguite tramite la classe System.Convert anziché con la semantica C# standard. In alcuni scenari queste conversioni provocano anche notevoli problemi di prestazioni. In Visual C# 2008 SP1, l'operatore Cast<T> viene modificato per generare un InvalidCastException per il tipo di valore numerico e le conversioni definite dall'utente. Questa modifica elimina sia la semantica dei cast C# non standard che i problemi di prestazioni. Tale modifica viene illustrata nell'esempio seguente.

using System;
using System.Linq;
class Program
{
    public struct S { }
    static void Main()
    {
        var floats = new float[] { 2.7f, 3.1f, 4.5f };
        var ints = from int i in floats 
                   select i;
// Visual C# 2008 SP1 throws InvalidCastException. 
        foreach (var v in ints) 
            Console.Write("{0} ", v.ToString());
        // The original release version of Visual C# 2008
        // compiles and outputs 3 3 4
    }
}

12

Conversioni di tipi

La conversione in enum di qualsiasi espressione costante con un valore pari a zero è ora consentita.

Il valore letterale 0 è convertibile in modo implicito in qualsiasi tipo enum. In Visual C# 2005 e nelle versioni precedenti del compilatore, ci sono anche alcune espressioni costanti che hanno un valore pari a 0 che possono essere convertite in modo implicito in qualsiasi tipo enum, ma la regola che determina quali di queste espressioni sono convertibili è poco chiara. In Visual C# 2008, tutte le espressioni costanti che sono uguali a 0 possono essere convertite in modo implicito in qualsiasi tipo enum.

Ciò potrebbe determinare alcune modifiche nel comportamento del codice esistente, ad esempio la risoluzione dell'overload del metodo che si basa sull'assenza di questa conversione implicita. Il codice seguente viene compilato correttamente in Visual C# 2005 e nelle versioni precedenti del compilatore, risolvendo la chiamata al metodo sul valore breve solo nell'overload int. In Visual C# 2008, questa chiamata è ambigua perché il valore breve è anche convertibile in modo implicito in E. In Visual C# 2008, il comportamento viene modificato per consentire la conversione di qualsiasi espressione costante che restituisce zero.

public enum E
{
    Zero = 0,
    One = 1,
} 
class A
{
    public A(string s, object o)
    { System.Console.WriteLine("{0} => A(object)", s); } 
    public A(string s, E e)
    { System.Console.WriteLine("{0} => A(Enum E)", s); }
} 
class B
{
    static void Main()
    {
        A a1 = new A("0", 0);
        A a2 = new A("1", 1);
        A a3 = new A("(int) E.Zero", (int) E.Zero);
        A a4 = new A("(int) E.One", (int) E.One);
    }
}
Visual C# 2005 output:
0 => A(Enum E)
1 => A(object)
(int) E.Zero => A(object)
(int) E.One => A(object)
Visual C# 2008 output:
0 => A(Enum E)
1 => A(object)
(int) E.Zero => A(Enum E)
(int) E.One => A(object)

14

Errori relativi ai tipi

È stato aggiunto un nuovo avviso sull'utilizzo di un membro del tipo di riferimento in una struttura.

Le regole di assegnazione definita per le strutture richiedono che la struttura sia impostata su un'istanza esistente del tipo o che ognuno dei membri sia assegnato prima che vi si faccia riferimento. In Visual C# 2005, quando viene utilizzato un membro del tipo di riferimento non assegnato di una struttura non viene generato alcun avviso o errore. In Visual C# 2008, viene generato l'Avviso del compilatore (livello 1) CS1060, come illustrato nell'esempio seguente.

    public class U { public int i;}
    public struct T { public U u;}
    class Program
    {
        static void Main()
        {
            T t;
// Produces CS1060:    
            t.u.i = 0; 
        }
    }

16

Controllo dell'overflow

Le conversioni in long non comprese nell'intervallo generano ora l'errore del compilatore corretto.

In Visual C# 2005, il codice seguente non genera un errore del compilatore. In Visual C# 2008, genera Errore del compilatore CS0031.

class Conversion 
    {
        static void Main() 
        {
            long l2 = (long) 9223372036854775808M; //CS0031 
        }
    }

18

Gli effetti collaterali sono ora mantenuti nelle espressioni null coalescing.

L'assegnazione definita e l'operatore ??.

In Visual C# 2005, in alcuni scenari gli effetti collaterali sul lato sinistro di un'espressione null coalescing non sono mantenuti. In questi casi, la seconda istruzione Console.WriteLine nell'esempio seguente genera un errore del compilatore errato che indica che b non è assegnato. In Visual C# 2008, lo stesso codice viene compilato correttamente senza errori.

        static void Main()
        {
            int? a, b;
            a = null;
            Console.WriteLine((b = null) ?? 17);
// No error in Visual C# 2008:Console.WriteLine(a + b);  

}

20

Interfacce e classi base

La costruzione della classe ignora ora le implementazioni esplicite degli stessi membri dell'interfaccia nelle classi base.

In Visual C# 2005, quando una classe non fornisce un'implementazione per un membro dell'interfaccia, il compilatore sostituisce le implementazioni della classe base anche se vengono dichiarate come implementazioni esplicite dell'interfaccia. Questo comportamento non è conforme alla specifica di ECMA (European Computer Manufacturers Association). Visual C# 2008 implementa correttamente la specifica. Nell'esempio seguente, Visual C# 2005 stampa "B.Test". Visual C# 2008 stampa correttamente "A.Test" e ignora il metodo Test nella classe B perché è un'implementazione esplicita dell'interfaccia.

using System;
interface ITest
{
    string Test { get; }
    string Test2 { get; }
}
class A : ITest
{
    public string Test { get { return "A.Test"; } }
    public string Test2 { get { return "A.Test2"; } }
}
class B : A, ITest
{
    string ITest.Test { get { return "B.Test"; } }
    string ITest.Test2 { get { return "B.Test2"; } }
}
class C : B, ITest
{
    string ITest.Test2 { get { return "C.Test2"; } }
}
class Program
{
    static void Main()
    {
        C c = new C();
        Console.WriteLine(c.Test); 
// Visual C# 2008: "A.Test"
    }

}

22

Errori durante la compilazione

L'utilizzo dell'opzione del compilatore /pdb senza /debug genera ora un errore.

In Visual C# 2005, non viene visualizzato alcun avviso o errore quando viene specificata l'opzione /pdb ma non l'opzione /debug. Visual C# crea solo una build di rilascio senza generare il file pdb. Nella versione finale originale di Visual C# 2008, se si specifica /pdb senza specificare anche /debug, il compilatore visualizza Errore del compilatore CS2036.

24

Controllo dell'overflow

Le conversioni da costante decimale a integrale generano ora un errore del compilatore diverso.

In Visual C# 2005, il codice seguente genererebbeErrore del compilatore CS0133: "L'espressione assegnata a 'b' deve essere costante".

const byte b = unchecked((byte)256M);

In Visual C# 2008, viene generatoErrore del compilatore CS0031: il "valore costante '256M' non può essere convertito in un 'byte'." Notare che l'errore viene generato anche se viene applicato il modificatore unchecked.

26

Errori relativi ai tipi

Un errore viene ora generato quando un tipo statico viene utilizzato come parametro in un delegato o in un'espressione lambda.

In Visual C# 2005, se un tipo statico viene utilizzato come parametro per un delegato o un metodo anonimo non viene generato alcun errore. I tipi statici non possono essere utilizzati come tipi di parametri del metodo perché non è possibile creare una loro istanza. La versione Visual C# 2005 del compilatore consente l'uso di tipi statici come tipi di parametro all'interno delle dichiarazioni di delegati e di metodi anonimi. Se si passa null come parametro, è possibile richiamare tali delegati. In Visual C# 2008, viene generato l'errore Errore del compilatore CS0721 se un tipo statico viene utilizzato come parametro per un delegato o un metodo anonimo, come mostrato nell'esempio seguente.

public static class Test { }
public class Gen<T> { }
// Produces CS0721:
delegate int D(Test f); 
public class TestB
{
    public static void Main()
    {
        D d = delegate(Test f) { return 1; };
    }

}

28

Risoluzione dell'overload

Un errore viene ora generato quando si verifica una risoluzione ambigua dell'overload sui metodi anonimi.

Le chiamate al metodo sui metodi di overload devono essere risolte dal compilatore per determinare quale overload specifico richiamare. Quando il tipo di parametro di una chiamata viene dedotto parzialmente, l'overload specifico da richiamare può diventare ambiguo. Questa situazione genera errori di compilazione.

Nel caso di un metodo anonimo passato come parametro del delegato, il tipo di delegato del metodo anonimo viene dedotto parzialmente. Ciò può causare ambiguità quando il compilatore deve selezionare l'overload corretto.

In Visual C# 2005, il compilatore non genera sempre un errore quando non esiste alcun overload migliore per un metodo anonimo. In Visual C# 2008, viene generato l'Errore del compilatore CS0121, come illustrato nell'esempio seguente.

class Program
{
    static int ol_invoked = 0;
    delegate int D1(int x);
    delegate T D1<T>(T x);
    delegate T D1<T, U>(U u);
    static void F(D1 d1) { ol_invoked = 1; }
    static void F<T>(D1<T> d1t) { ol_invoked = 2; }
    static void F<T, U>(D1<T, U> d1t) { ol_invoked = 3; }
    static int Test001()
    {
// Produces CS0121:
        F(delegate(int x) { return 1; });         if (ol_invoked == 1)
            return 0;
        else
            return 1;
    }
    static int Main()
    {
        return Test001();
    }
}

30

Risoluzione dell'overload

Un avviso viene ora generato quando i metodi candidati della risoluzione dell'overload variano solo in base a ref o out.

In Visual C# 2005, quando il compilatore C# esegue la risoluzione dell'overload sui tipi generici, non verifica se gli argomenti di tipo faranno in modo che i metodi candidati varino solo in base a ref o out. Di conseguenza, la scelta dei metodi viene lasciata al Common Language Runtime (CLR) in fase di esecuzione e si limita a selezionare il primo metodo dell'elenco. In Visual C# 2008, Avviso del compilatore (livello 1) CS1956 viene generato quando il compilatore rileva che due metodi candidati per la risoluzione dell'overload varieranno solo in base a ref o out. Tale condizione viene illustrata nell'esempio seguente.

using System;
class Base<T, S>
{
// Produces CS1956:
    public virtual void Test(out T x) 
    {
        Console.WriteLine("Test(out T x)");
        x = default(T);
    }
    public virtual void Test(ref S x)
    {
        Console.WriteLine("Test(ref T x)");
    }
}
interface IFace
{
    void Test(out int x);
}
class Derived : Base<int, int>, IFace
{
    static void Main()
    {
        IFace x = new Derived();
        int y;
        x.Test(out y);
    }

}

Luglio 2008

Argomento aggiunto.

Modifica di funzionalità in SP1.