lunedì 28 dicembre 2009

PowerPoint 2010 : Trasmettere la propria presentazione in broadcast

Forse non tutti sanno che è possibile “proiettare” una presentazione PowerPoint 2010 in broadcast ad utenti connessi in rete.

La modalità con cui si esegue questa operazione è molto semplice.

Innanzitutto è necessario disporre di un account LiveID, poi, basta utilizzare l’opzione “Broadcast Slide Show” del ribbon “Slide Show”:

klklA questo punto, è necessario scegliere il servizio di broadcast da utilizzare.

dsd

Per default viene proposto quello di PowerPoint ma può essere cambiato (grazie al tasto “Change Broadcast Service”) aggiungendone altri.

Selezionato il servizio di broadcast, possiamo premere il tasto “StartBroadcast” e PowerPoint comincerà a creare il broadcast.

kjkAl termine dell’operazione verrà proposto il link da utilizzare per poter vedere, live in broadcast, la presentazione:

ioio

Possiamo distribuire il link via mail o tramite qualsiasi altro mezzo copiandolo e inviandolo ai nostri destinatari.

Per iniziare la presentazione premiamo il tasto “Start Slide Show” e possiamo cominciare a visualizzare la nostra presentazione come se il nostro pubblico stesse vedendo il nostro schermo. Mentre noi cambieremo slide in locale, gli utenti connessi vedranno la relativa slide in broadcast.

Secondo me si tratta di una funzionalità interessante da poter utilizzare quando abbiamo utenti remoti difficilmente raggiungili con un collegamento intranet.

venerdì 25 dicembre 2009

giovedì 24 dicembre 2009

Accelerator Creation Guide

Vorrei segnalarvi, dal blog di IE, un tutorial su come realizzare un accelerator di IE8:

IEBlog : Accelerator Creation Guide

Vi ricordo, inoltre, che potete scaricare le slides della tappa romana del Community Tour 2009 di Microsoft in cui troverete anche delle slides e del codice sugli accelerator.

Questo è il link al post sul materiale del community tour:

http://codetailor.blogspot.com/2009/12/community-tour-2009-materiale-della-mia.html

mercoledì 23 dicembre 2009

VS2010 – VB.NET : Array Literals

Visual Basic 10 mette a disposizione la possibilità di creare array di oggetti in maniera rapida e compatta.

Ad esempio prendiamo in esame la classe:

  1. Public Class Repository
  2.  
  3.     Public Function GetIntegerArray() As Integer()
  4.         Dim arr = {3, 7, 10, 12, 6, 2, 1}
  5.         Return arr
  6.     End Function
  7.  
  8. End Class

Osserviamo che l’array di Integer arr è stato definito, riempito ed istanziato con una sola istruzione in maniera molto compatta.

Il compilatore riesce ad applicare la local type inference all’array così creato, infatti se posizioniamo il cursore al di sopra della definizione di arr, otteniamo:

aa Vediamo come si comporta il compilatore dietro le quinte analizzando il codice generato grazie a Reflector:

aaa Come possiamo osservare, il compilatore non fa altro che utilizzare la consueta sintassi per l’inizializzazione degli array (come avremmo fatto in VB.NET 9).

Il compilatore è in grado di dedurre il tipo degli oggetti componenti l’array andando a vedere quale è il tipo in grado di contenere tutti gli oggetti presenti nelle parentesi graffe.
Per questo motivo possiamo avere, all’interno delle graffe di definizione dell’array, anche oggetti di differente tipologie come, ad esempio:

  1. Dim oggetti = {1, "a", True}

In questo caso, il compilatore dedurrà che oggetti è un array di Object.
Questo tipo di assegnazione con oggetti di differente natura funziona solo se abbiamo la direttiva Option Strict Off.
In caso contrario si ottiene un errore.

Infine, osserviamo che questo modo di definire gli array funziona anche per array costituiti da nostre classi:

  1. Public Function GetCustomerArray() As Customer()
  2.     Dim arr = {New Customer() With {.Id = 1, .FirstName = "Giuseppe", .LastName = "Verdi"},
  3.                 New Customer() With {.Id = 2, .FirstName = "Carlo", .LastName = "Rossi"},
  4.                 New Customer() With {.Id = 3, .FirstName = "Filippo", .LastName = "Bianchi"}}
  5.     Return arr
  6. End Function

martedì 22 dicembre 2009

Il blog del team MSDN Italia : Esteso il periodo della beta di Visual Studio 2010 e .NET Framework 4

Riporto un post apparso oggi sul blog MSDN che conferma il rilascio di una RC di Visual Studio 2010 a Febbraio

…… A febbraio 2010 uscirà una Release Candidate con licenza “go live” molto estesa, mentre l’uscita finale verrà posticipata di qualche settimana rispetto alla data precedentemente annunciata. ……

Ecco il link all’intero post:

Il blog del team MSDN Italia : Esteso il periodo della beta di Visual Studio 2010 e .NET Framework 4

VS2010 – VB.NET : Collection Initializers

Altra nuova funzionalità di linguaggio inserita nella versione VB.NET 10 è la possibilità di definire, istanziare e riempire delle collezioni di oggetti in un unica istruzione.

Nelle versioni precedenti di VB.NET avevamo bisogno di scrivere:

  1. Dim list = New List(Of Integer)
  2. With list
  3.     .Add(1)
  4.     .Add(2)
  5.     .Add(3)
  6.     .
  7.     .
  8. End With

Nella versione 10 di VB.NET possiamo, invece, scrivere

  1. Dim list = New List(Of Integer) From
  2.             {1,2,3,.,.,.,.}

I valori passati dopo la clausola From possono anche essere delle variabili.

Ma come si comporta il compilatore quando utilizziamo la nuova sintassi?

Per verificare ciò, supponiamo di avere la seguente classe:

  1. Public Class CityRepository
  2.  
  3.     Public Function GetCity() As List(Of String)
  4.         Dim cityList = New List(Of String) From
  5.                         {"Roma",
  6.                          "Milano",
  7.                          "Napoli",
  8.                          "Genova",
  9.                          "Firenze",
  10.                          "Torino"}
  11.         Return cityList
  12.     End Function
  13. End Class

Se la compiliamo (inserendola in un progetto Visual Studio 2010) ed analizziamo l’assembly ottenuto utilizzando Reflector, otteniamo:

aa

Possiamo osservare che il compilatore, di fatto, fa esattamente quello che avremmo fatto noi, creando una variabile d’appoggio, riempiendola con i valori e restituendola al chiamante.

Non c’è traccia della nostra variabile cityList. In effetti il compilatore si accorge che la nostra cityList è, di fatto, una variabile di appoggio, mai utilizzata nella funzione e immediatamente restituita ed effettua una sorta di ottimizzazione del codice.

Se, infatti, modifichiamo la classe nel seguente modo:

  1. Public Class CityRepository
  2.  
  3.     Public Function GetCity() As List(Of String)
  4.         Dim cityList = New List(Of String) From
  5.                         {"Roma",
  6.                          "Milano",
  7.                          "Napoli",
  8.                          "Genova",
  9.                          "Firenze",
  10.                          "Torino"}
  11.         cityList.Add("Udine")
  12.         Return cityList
  13.     End Function
  14. End Class

Otteniamo:

dd

In questo caso, la variabile di appoggio introdotta dal compilatore viene “travasata” nella nostra variabile cityList subito dopo aver terminato di aggiungere gli elementi nella definizione iniziale.

Ciò che possiamo dedurre da queste osservazioni è che l’inizializzazione delle collezioni in un’unica riga non ottimizza le performance del codice ma migliora semplicemente la leggibilità (e già sarebbe sufficiente per utilizzarla) essendo assolutamente identica (a livello di codice compilato) della modalità con cui si creavano analoghe liste in VB.NET 9.

In realtà non è esattamente così e per verificarlo supponiamo di avere la seguente classe:

  1. Public Class IntegerRepository
  2.  
  3.     Public Function GetList() As List(Of Integer)
  4.         Dim lista As List(Of Integer) = Nothing
  5.         Try
  6.             lista = New List(Of Integer)
  7.             With lista
  8.                 .Add(2)
  9.                 .Add(4)
  10.                 .Add(System.Convert.ToInt32("a"))
  11.                 .Add(6)
  12.             End With
  13.         Catch ex As Exception
  14.  
  15.         End Try
  16.         Return lista
  17.     End Function
  18. End Class

Evidentemente, viene sollevata un’eccezione nel momento in cui si cerca di convertire la stringa “a” in un intero.

All’uscita della funzione, la lista è, però parzialmente valorizzata (sono infatti presenti i valori 2 e 4 ma non il 6).

dddd Se, ora modifichiamo la classe nel seguente modo:

  1. Public Class IntegerRepository
  2.  
  3.     Public Function GetList() As List(Of Integer)
  4.         Dim lista As List(Of Integer) = Nothing
  5.         Try
  6.             lista = New List(Of Integer) From
  7.                 {2, 4, 6, System.Convert.ToInt32("a")}
  8.         Catch ex As Exception
  9.  
  10.         End Try
  11.         Return lista
  12.     End Function
  13. End Class

Otteniamo che la lista di ritorno, nonostante sia sempre sollevata l’eccezione, è vuota (anzi non è neanche istanziata):

21-12-2009 14-02-56

In sostanza, utilizzando la nuova sintassi si realizza una sorta di “transazione” nell’operazione di definizione/istanziazione/riempimento della lista: o abbiamo la lista completa o niente.

Se mettiamo a confronto le due funzioni (rinominando GetListOld() quella creata nella vecchia maniera) possiamo analizzare il codice generato con Reflector e vedere che il compilatore si comporta in maniera completamente differente:

rerer

Utilizzare, quindi, i collection inizializers non è solo un modo per ottenere una sintassi compatta e più leggibile ma anche un modo per ottenere una transazione nell’operazione di creazione di una collection.

Prima di chiudere vorrei evidenziare il fatto che la collection inizializer si basa, come abbiamo visto, sull’utilizzo del metodo Add della collezione che stiamo istanziando. Questo significa che, se per caso, ridefiniamo tale metodo, tutto funziona in maniera automatica.

Ad esempio supponiamo di definire una classe Customer:

  1. Public Class Customer
  2.     Property ID As Integer
  3.     Property FirstName As String
  4.     Property LastName As String
  5. End Class

e di definire un metodo di estensione Add() che agisce su un’istanza dell’interfaccia IList e aggiunge un nuovo Customer:

  1. Imports System.Runtime.CompilerServices
  2.  
  3. Public Module Module1
  4.  
  5.     <Extension()>
  6.     Public Sub Add(ByVal list As IList(Of Customer),
  7.                     ByVal ID As Integer,
  8.                     ByVal FirstName As String,
  9.                     ByVal LastName As String)
  10.  
  11.         list.Add(New Customer With {.ID = ID,
  12.                                     .FirstName = FirstName,
  13.                                     .LastName = LastName})
  14.     End Sub
  15.  
  16. End Module

In questo modo creiamo una sorta di overload del metodo Add dell’interfaccia IList ed il compilatore è in grado di risolvere la seguente istruzione:

  1. Dim list As New List(Of Customer) From {
  2.             {1000, "Mario", "Rossi"},
  3.             {1100, "Giuseppe", "Verdi"},
  4.             {1200, "Carlo", "Bianchi"}}

restituendoci una lista di tre oggetti Customer:

sassa Se analizziamo il codice generato dal compilatore, ci rendiamo conto che viene, effettivamente, richiamato il nostro metodo di estensione:

hggh

lunedì 21 dicembre 2009

Community Tour 2009 – Materiale della mia sessione

Eccovi, come promesso, il materiale della mia sessione su Internet Explorer 8 e gli strumenti per sviluppatori tenuta nella tappa romana del Community Tour 2009.

Il materiale è disponibile (assieme al materiale di tutte le sessioni) anche sul sito della community DotNetRomaCestà all’indirizzo:

http://www.dotnetromacesta.org/EventoCommunityTour.aspx

Per qualsiasi dubbio o domanda scrivetemi pure senza problemi, compatibilmente con gli impegni lavorativi cercherò di rispondervi subito.

VS2010 – VB.NET : Multiline lambda expression

In Visual Basic 10 è possibile definire delle lambda expression su più linee.

In sostanza si tratta di funzioni definite “in-line” che possono estendersi anche su più linee.

Un esempio di ciò che si intende è il seguente:

  1. Dim intList = {1, 4, 7, 3, 8, 2, 5, 9, 0}
  2.  
  3. Dim query = Array.FindAll(intList,
  4.                           Function(x)
  5.                               Dim retVal As Boolean = False
  6.                               If x > 6 Then
  7.                                   retVal = True
  8.                               Else
  9.                                   If x \ 2 = 1 Then
  10.                                       Return True
  11.                                   End If
  12.                               End If
  13.                               Return retVal
  14.                           End Function)

Le lambda expression multilinea possono essere sia Function che Sub.

E’ possibile utilizzare le lambda expression multilinea anche per assegnare dei gestori di eventi “al volo”:

  1. AddHandler Me.Button2.Click, Sub()
  2.                                  MessageBox.Show("Ciao")
  3.                              End Sub

Come si comporta, però, il compilatore quando utiliziamo questa nuova funzionalità del linguaggio.

Compiliamo la seguente classe:

  1. Public Class Class1
  2.  
  3.     Private Sub Main()
  4.         Dim intList = {1, 4, 7, 3, 8, 2, 5, 9, 0}
  5.  
  6.         Dim query = Array.FindAll(intList,
  7.                                   Function(x)
  8.                                       Dim retVal As Boolean = False
  9.                                       If x > 6 Then
  10.                                           retVal = True
  11.                                       Else
  12.                                           If x \ 2 = 1 Then
  13.                                               Return True
  14.                                           End If
  15.                                       End If
  16.                                       Return retVal
  17.                                   End Function)
  18.     End Sub
  19.  
  20. End Class

ed analizziamo il risultato della compilazione con Reflector di Red Gate, otteniamo:

reflector

Come possiamo osservare il compilatore genera un metodo statico chiamato _Lambda$__1 in cui inserisce il codice presente nella lambda multilinea (tra le altre cose ottimizzato togliendo l’IF).

Questo ci dice che creare delle lambda multilinea non è diverso che creare un metodo che esegue lo stesso algoritmo. Non si ha, in questo caso, una ottimizzazione nell’uso delle lambda multilinea.

venerdì 18 dicembre 2009

VS2010 – VB.NET : Definizione compatta delle proprietà

Una interessante feature inserita in Visual Studio 2010 è quella (già esistente nel linguaggio C# in Visual Studio 2008) di poter definire in maniera compatta quelle proprietà di tipo”standard” (cioè con setter e getter standard).

Nelle precedenti versioni di Visual Studio avremmo dovuto scrivere:

Private _FirstName As String
Public Property
FirstName As String
Get
Return Me
._FirstName
End Get
Set
(ByVal value As String)
Me._FirstName = value
End Set
End Property


Attualmente, In Visual Studio 2010, possiamo scrivere:



Public Property FirstName As String


Con un notevole risparmio di tempo e leggibilità del codice.



Ma cosa succede dietro le quinte nel momento in cui compiliamo una classe con le proprietà definite in questo modo?



Supponiamo di avere la semplice classe:



Public Class Person
Public Property FirstName As String
Public Property
LastName As String
End Class


Se apriamo l’assembly generato dalla compilazione con uno strumento che ci consente di vedere cosa viene generato come, ad esempio Reflector di Red Gate, osserviamo:



reflector1



Come possiamo vedere, il compilatore ha generato la proprietà in maniera molto simile a come l’avremmo implementata noi.



Unica differenza è la presenza dell’attributo CompilerGeneratedAttribute che indica il fatto che l’attributo privato è stato generato dal compilatore e non scritto dall’utente.



Possiamo utilizzare l'attributo CompilerGeneratedAttribute per determinare se un membro di una classe è stato aggiunto da un compilatore oppure è stato inserito dallo sviluppatore.



Questo attributo è presente nel framework fin dalla versione 2.0.



 



Visual Studio 2010 : RC a Febbraio

Come potete leggere nei post seguenti, il gruppo di sviluppo di Visual Studio 2010 ha deciso di rilasciare una Release Candidate di prodotto a Febbraio 2010 prima del definitivo rilascio (che, a questo punto è fissato a data da destinarsi):

http://blogs.msdn.com/somasegar/archive/2009/12/17/visual-studio-2010-and-net-framework-4-beta-period-extended.aspx

http://weblogs.asp.net/scottgu/archive/2009/12/17/visual-studio-2010-and-net-4-0-update.aspx

giovedì 17 dicembre 2009

Interessante webcast sull’utilizzo di TFS Basic

Vorrei segnalarvi un post del mitico Matteo in cui viene riportato un webcast sull’utilizzo del TFS Basic.

Team System, Virtualization @ University » TFS Basic Usage for a single developer

Vi consiglio di dargli un’occhiata perché è veramente ben fatto.

venerdì 11 dicembre 2009

.NET Campus - Meet, Learn, Share

Posto un nuovo evento targato Microsoft e decisamente interessante che si svolgerà a Roma in Marzo 2010:

.NET Campus è un evento per sviluppatori organizzato dal gruppo DevLeap in collaborazione con il gruppo dei Microsoft Student Partner e le Community più attive per fornire a studenti e aziende un’intensa mattinata di sessioni tecniche presso l’università Roma 3. Insieme alle sessioni tecniche orientate alle novità che ruotano intorno al mondo .NET, la giornata rappresenta un momento unico dove aziende e studenti possono incontrarsi per confrontare i loro mondi e unire le loro esperienze.

Per capire di cosa si tratta ed iscriversi andate sul sito:

http://www.dotnetcampus.it/

Anche DotNetRomaCestà collaborerà per la realizzazione dell’evento.

 

Technorati Tag: ,

domenica 6 dicembre 2009

Real Code Day 4 : Impressioni

L’altro ieri si è tenuto, a Firenze, Real Code Day 4 (tappa Community Tour 2009) e, ovviamente, non me lo potevo far scappare.

Il tempo è stato infame, il traffico di Firenze deveastante (giuro che non mi lamento più di quello romano), il parcheggio non proprio agevole, però l’evento è stato decisamente sufficiente.

Tanti i partecipanti hanno costretto gli organizzatori a suddividere i presenti in tre sale (una con gli speaker e le altre due connesse con Live Meeting).

Purtroppo la mattinata è stata funestata da tanti problemi tecnici che non hanno permesso di seguire agevolmente le sessioni. Il pomeriggio, invece, è andata decisamente meglio con sessioni interessanti e ricche di spunti (interessante quella su MicroFramework).

Alla fine un discreto evento. Probabilmente è valsa la pena farsi 350+350 Km in una giornata! Mi sento di muovere solo l’appunto della sala piccola per tutta la gente presente, ma credo che vista l’esperienza degli organizzatori oramai decennale, la prossima volta andrà meglio.

 

venerdì 4 dicembre 2009

mercoledì 2 dicembre 2009

Community Tour 2009 Tappa Romana : 15 giorni all’ora X

Solo 15 giorni ci separano dalla tappa romana del Community Tour 2009 a cura di DotNetRomaCestà.

Terrò una sessione:

Internet Explorer 8 for Developers
La nuova versione del browser Microsoft, oltre a miglioramenti di performance ed usabilità, mette a disposizione dello sviluppatore degli strumenti per lo sviluppo di applicazioni più interattive e per il debug più semplice ed efficiente. La sessione vuole dare una visione di insieme sulle novità introdotte in IE8 e come utilizzarle praticamente nelle nostre applicazioni.

Se non vi siete ancora iscritti non indugiate oltre perchè ne vale la pena. Andate al link per iscrivervi.

Vi aspetto il 17 Dicembre 2009!!!!

 

Il blog del team MSDN Italia riporta DotNetRomaCesta

DotNetRomaCestà è segnalata sul blog di MSDN nella sezione dei link di dicembre:

Il blog del team MSDN Italia : Community Links: dicembre, ASPItalia, VB Tips & Tricks, dotNetRomaCesta

Grossa soddisfazione per una quasi neonata community.

 

martedì 1 dicembre 2009

VS2010 Beta 2: Sequence Diagram di metodi richiamati ricorsivamente

Interessante possibilità offerta da Visual Studio 2010 beta 2 è la generazione dei diagrammi di sequenza a partire dai metodi di una nostra classe. Ma come si comporta se nei nostre elucubrazioni object oriented sono presenti metodi ricorsivi?

Supponiamo di avere la nostra classe:

Public Class ClasseA
    Public Sub MetodoA(ByVal control As Control)
        For Each childControl In control.Controls.OfType(Of Control)()
            MetodoA(childControl)
        Next
    End Sub
    Public Sub MetodoB()
        For index = 0 To 10
            MetodoC()
        Next
    End Sub
    Public Sub MetodoC()
    End Sub
End Class


Per generare il diagramma di sequenza del MetodoA è sufficiente utilizzare il menù contestuale che si ottiene andando sul metodo e premendo il tasto destro:



image selezionare la profondità del diagramma di sequenza:



image e premere il tasto Ok.



A questo punto, Visual Studio lavora un pochino (in base alla complessità del metodo e alla profondità richiesta) e genera il diagramma di sequenza:



imagePossiamo osservare che Visual Studio si rende conto che il MetodoA è chiamato in maniera ricorsiva all’interno di un loop e ce lo indica con la dicitura “Recurse to this.MetodoA” (molto C#esca ma efficace).





Se proviamo a generare il diagramma di sequenza del MetodoB otteniamo:



image Il diagramma mostra, questa volta, un loop con la chiamata al MetodoC non ricorsivo (come è giusto che sia).



Alla fine sembrerebbe che Visual Studio 2010 beta 2 comprenda correttamente la ricorsività e, questo, non può che farci piacere.



VB.NET : Creare un file XML con gli appSettings del file di configurazione utilizzando LINQ

Questo piccolo tip mostra come è possibile creare un file XML in cui ricopiare le chiavi della sezione appSettings del file di configurazione dell’applicativo utilizzando LINQ ed in particolar modo la funzionalità di XML Literal del VB.NET.

La funzione in esame è la seguente:

Public Function CreateLocalConfigurationFile(ByVal fileName As String) As Boolean
    Dim retval = True
    Dim xdoc As XDocument = _
            <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
            <configuration>
                <%= From key In ConfigurationManager.AppSettings.Keys _
                    Select <key name=<%= key %> value=<%= ConfigurationManager.AppSettings(key.ToString()) %>/> _
                %>
            </configuration>
    Try
        Dim docPath = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
        xdoc.Save(fileName)
    Catch ex As Exception
        retval = False
    End Try
    Return retval
End Function


In sostanza viene creta un’istanza della classe XDocument utilizzando XML LIteral in cui utilizziamo una query LINQ sulla collection ApSettings della classe ConfigurationManager.



Per poter utilizzare la classe ConfigurationManager è necessario referenziare la libreria System.Configuration.



In pratica, supponendo che il file di configurazione abbia la seguente sezione appSettings:



<configuration>
  <appSettings>
    <add key="key1" value="value1"/>
    <add key="key2" value="value2"/>
    <add key="key3" value="value3"/>
    <add key="key4" value="value4"/>
  </appSettings>
</configuration>


Si ottiene il seguente file XML:



<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<configuration>
  <key name="key1" value="value1" />
  <key name="key2" value="value2" />
  <key name="key3" value="value3" />
  <key name="key4" value="value4" />
</configuration>


Ovviamente è possibile utilizzare l’algoritmo per scrivere su file XML qualsiasi collezione di elementi.



venerdì 27 novembre 2009

Articolo su ioProgrammo 145 di Dicembre

Sul numero di dicembre 2009 di ioProgrammo è uscito un mio articolo sulla piattaforma Bing:

BING

Le API del motore di ricerca sono facilissime: poche righe in VB.NET per avere risultati super nelle nostre applicazioni

ioProgrammo-145

 

giovedì 26 novembre 2009

VB.NET : Aggregare stringhe con LINQ

Tip facile facile, ma a qualcuno potrebbe servire.

Supponiamo di avere una lista di stringhe (magari come risultato di una query LINQ) e di voler ottenere una stringa con la concatenazione delle stesse:

Dim list = CreateList()
Dim concatStr = (From s In list _
                Select s).Aggregate(Function(currentString, nextString) currentString + nextString)
MessageBox.Show(concatStr)


Il metodo CreateList non ci interessa, in questo momento, ma crea una lista di oggetti String.



Protected Function CreateList() As IEnumerable(Of String)
    Dim list As String() = {"stringa1", "stringa2", "stringa3", "stringa4", "stringa5"}
    Return list.AsEnumerable()
End Function


Questo metodo potrebbe restituire una qualsiasi lista di oggetti di cui, nella select successiva recuperiamo solo stringhe.



La stessa tecnica è utilizzabile per concatenare stringhe inserendovi un carattere separatore



Dim list = CreateList()
Dim separator = ";"
Dim concatStr = (From s In list _
                Select s).Aggregate(Function(currentString, nextString) _
                                        currentString + separator + nextString)
MessageBox.Show(concatStr)


Attenzione perché Aggregate() non funziona con LINQ to SQL.