Event Description: TF30162: Task "SharePointPortal" from Group "Portal" failed
Exception Type: Microsoft.TeamFoundation.Client.PcwException
Exception Message: An error occurred in the New Team Project Wizard while attempting to create a site on the following SharePoint Web application: server.
Exception Details: The Project Creation Wizard encountered a problem while uploading documents to the following server running SharePoint Products: server. The reason for the failure cannot be determined at this time. Because the operation failed, the wizard was not able to finish creating the team project.
Stack Trace:
   at Microsoft.VisualStudio.TeamFoundation.WssSiteCreator.Execute(ProjectCreationContext context, XmlNode taskXml)
   at Microsoft.VisualStudio.TeamFoundation.ProjectCreationEngine.TaskExecutor.PerformTask(IProjectComponentCreator componentCreator, ProjectCreationContext context, XmlNode taskXml)
   at Microsoft.VisualStudio.TeamFoundation.ProjectCreationEngine.RunTask(Object taskObj)
–   Inner Exception   —
Exception Message: Server was unable to process request. —> Lingua non supportata nel server. —> Lingua non supportata nel server. (type SoapException)
Exception Stack Trace:    at Microsoft.VisualStudio.TeamFoundation.WssSiteCreator.HandleSiteCreation(WssCreationContextWrapper contextWrapper, XmlNode taskNode)
   at Microsoft.VisualStudio.TeamFoundation.WssSiteCreator.Execute(ProjectCreationContext context, XmlNode taskXml)

Questo succede perché la lingua utilizzata da Visual Studio (l’inglese) non è supportata da SharePoint. Per ovviare a questo banale inconveniente è sufficiente installare sul server SharePoint il pacchetto “2010 Server Language Packs for SharePoint Server 2010, Project Server 2010, Search Server 2010, and Office Web Apps 2010” in inglese oppure nella lingua nativa di Visual Studio.

Soluzione 1

1. Eseguire Visual Studio in modalità Safe Mode con il comando: devenv.exe /safemode
2. Aprire un nuovo progetto Windows Application
3. Selezionare Chooise Items dalla Toolbox
4. Chiudere e riavviare normalmente

Soluzione 2

1. Eseguire il comando: devenv /setup
2. Eseguire il comando: devenv /resetuserdata
3. Eseguire il comando: devenv /resetsettings CSharp

In questo articolo ci concentreremo esclusivamente sulle novità apportate al linguaggio C# 4.0. Molte delle novità descritte in questo articolo sono già testabili scaricando e installando la Microsoft Pre-release Software Visual Studio 2010 and .NET Framework 4.0 Community Technology Preview. Si tratta di una macchina Virtual PC con dentro Windows, Visual Studio 2010 e il .net framework già installati e configurati. Per un totale di circa 7GB di macchina virtuale!

Complessivamente le novità introdotte in C# 4.0 si possono riassumere nel seguente elenco:

1. Dynamic Type Object
2. Name e Optional Arguments
3. Co-variance e Contra-variance
4. Migliorie su COM Interop

Vediamo in dettaglio.

Dynamic Type Object

Il Dynamic Type Object è un nuovo tipo statico introdotto soprattutto a beneficio del Dynamic Language Runtime (DLR). Con la nuova parola chiave dynamic è possibile dichiarare un type che verrà risolto solo a run-time. In questo modo:

public void MyFunction()
{
    // le seguenti variabili verranno convertite
    // implicitamente a run-time. 
    dynamic counter = 1;
    dynamic hello = "Hello C# 4.0";
}

Su un type dichiarato come dynamic è possibile richiamare metodi, campi o proprietà, come se fosse un object. Il tutto verrà risolto automaticamente a run-time in base al type effettivo contenuto all’interno della variabile. Con questa parola chiave C# 4.0 si uniforma così ai tipici linguaggi dinamici (dynamic appunto) come Ruby o Php.

Name e Optional Arguments

L’optional argument è una funzionalità del linguaggio già presente in Visual Basic ed è la capacità di dichiarare come opzionale un parametro di un metodo, in questo modo:

// il parametro i risulta essere obbligatorio
// mentre il parametro y è optionale e per
// default viene impostato a 0.
public int Calc(int i, int y = 0)
{
    // corpo del metodo
}

public void Main()
{
    // ho la possibilità di richiamare Calc con un
    // solo parametro o con due, poiché il parametro
    // y risulta essere opzionale.
    int result1 = Calc(5); // equivalente a Calc(5, 0);
    int result2 = Calc(10, 3)
}

Il name argument invece è la facoltà di passare un parametro per nome, in questo modo:

public int Calc(int i, int y = 0, int z = 1)
{
    // corpo del metodo
}

public void Main()
{
    // In questo modo chiamo il metodo Calc con i parametri
    // invertiti, cioè prima passando y e poi x.
    int result = Calc(y: 3, i: 4); // equivalente a Calc(4, 3, 0);

    // In questo, invece chiamo Calc passando i e z ma non y
    int result2 = Calc(z: 6, i: 3); // equivalente a Calc(3, 0, 6);
}

Co-variance e Contra-variance

Introduciamo il concetto di covarianza e contravarianza. Date due classi A e B. Dove B è una sotto classe di A, e avente una nuova classe C<T> si dice che C<T> è covariante rispetto a T se anche C<B> è una sotto classe di C<A>. Mentre si dice che C<T> è contravariante rispetto a T se anche C<A> è super classe di C<B>. In pratica:

• se B è sotto classe di A
• la classe C<B> è covariante rispetto a T con C<A> se C<B> è sotto classe di C<A>
• la classe C<A> è contravariante rispetto a T con C<B> se anche C<A> è super classe di C<B>

Questo risulta particolarmente interessante con i type parameter dei generics. In questo modo potremmo, per esempio, assegnare una collection di stringhe ad una collection di oggetti, dato che la classe string e sotto classe di object, o vice versa, così:

IList<string> strings = new List<string>();
IList<object> objects = strings;

I benefici della covarianza e della contravarianza non si limitano a questo aspetto, ma come esempio è chiarificatore.

Migliorie su Com Interop

Tra le migliorie su Com Interop citiamo:

• Importazione dinamica con l’utilizzo del Dynamic Type Object invece che object
• Compilazione senza PIA (Primary Interop Assemblies) che rendevano pensante l’applicazione
• Chiamate a metodi senza l’utilizzo di ref

Conclusioni

Che dire, le novità sono davvero tante e tutte decisamente interessanti. Prima tra tutte la citata parolina magica dynamic, che introduce una vera e propria rivoluzione per un linguaggio prettamente statico come C#. Non resta che aspettare l’uscita ufficiale sia del .Net Framework 4.0 ma soprattutto del nuovissimo Visual Studio 2010 che merita veramente la visione, ma questa è un‘altra storia.

Risorse

Alcune risorse utili:

• Il pdf del poster .Net Framework 4.0
• Visual Studio 2010 and .NET Framework 4.0 Training Kit
• Mix It Up: Visual Studio 2010 and ASP.NET 4.0
• C# Future

Rispetto alla versione precedente (la 4.1) questa è risultata però decisamente più pesante, sia in termini di memoria che in termini di velocità. Nonostante infatti i dichiarati miglioramenti di prestazioni e di consumo di memoria, aprendo la solution il consumo di memoria, al termine del caricamento, è passato da 700mb con vecchia versione a oltre 1GB con quella nuova. Nel task manager notiamo inoltre, un nuovo processo dal nome JetBrains.Resharper.ExeternalProcessStorage.Process.exe, prima inesistente, che consuma altri 20mb.

Tra le novità interessanti il Solution-Wide Code Inspections ora più preciso, anche se decisamente più lento, in grado di rilevare:

• Dichiarazioni non private che non sono utilizzate
• Valori di ritorno non utilizzati di metodi non privati
• Campi privati non utilizzati
• Parametri non utilizzati di membri non privati
• Eventi abstract o virtual che non vengono mai invocati
• Campi non assegnati
• Membri e tipi public che possono essere convertiti in internal

Ho provato sul campo il Solution-Wide Code Inspections che mi ha dato ottimi risultati rilevando problemi anche in classi e metodi particolarmente complessi. Attenzione però il Solution WiceCode Inspections può durare, in una prima fase, anche alcune ore dipendente dalla dimensione della solution, degradando le prestazioni del computer senza impedire però il continuo svolgimento del proprio lavoro.

Oltre al supporto per Visual Basic 9, finalmente è arrivata la funzionalità di Extended Naming Style Configuration che ci permette di configurare tutta una serie di naming convention su namespace, metodi, classi, interfacce, campi e proprietà. Prima di oggi questa funzionalità era disponibile solo con appositi plugin di terze parti. Dal pannello delle opzioni, tramite una comoda interfaccia, è possibile specificare la convezione da applicare in base al tipo di membro. Tra le possibilità possiamo specificare un prefisso, un suffisso oltre alla stile suddiviso in UpperCamelCase, lowerCamelCase, ALL_UPPER, all_lower e First_upper. Queste convenzioni sono configurabili a livello globale o per linguaggio.

Non da ultimo ci sono piccole ma sostanziali migliorie come il supporto nativo all’MSTest, nuove funzionalità di navigazione, nuove inline refactoring e tanto altro.

In definitiva ReSharper si conferma il miglior strumento per lo sviluppo in ambito .net e nonostante le performance in alcuni casi deludenti, le novità introdotte sono tante e soprattutto molto utili. Decisamente consigliato.

string value = ConfigurationManager.AppSettings[key];

Tuttavia con Visual Studio 2005 potreste incontrare un problema di riconoscimento delle nuove classi con l’intellisense. Il problema nasce poiché Visual Studio non riconosce correttamente la versione del file System.Configuration. Il risultato è un intellisense che mostra l’elenco delle classi e delle funzioni della versione 1.1 del .NET Framework:

Per risolvere questo problema basta referenziare la dll System.Configuration v2.0 semplicemente facendo Add Reference > System.Configuration.dll per tutti i progetti che necessitano il riconoscimento della nuova classe.

Riferimenti
http://aspadvice.com/blogs/ssmith/archive/2005/08/26/1912.asp
ConfigurationManager su MSDN

Tags: visual studio, intellisense, configurationmanager