[gugoXX]

Originariamente inviato da cdimauro

Ricca varietà di tipi di dati predefiniti (riporto i più importanti e "particolari"):
- interi (illimitati. Es: 1 << 256 = 115792089237316195423570985008687907853269984665640564039457584007913129639936L);
- stringhe (queste devi provarle: per la manipolazione delle stringhe Python è particolarmente comodo e versatile; esempietto al volo: s = ', '.join(['Qui', 'Quo', 'Qua']) produce s = 'Qui, Quo, Qua'), con supporto anche allo unicode (quindi posso avere stringhe che contentono sequenze di byte, oppure sequenze di caratteri unicode; la gestione è esattamente la stessa);
- tuple, cioé sequenza di oggetti immodificabile (per restituire più valori o s/impacchettarli; es: return 'Qui', 'Quo', 'Qua' in una funzione, oppure x, y, z = 'Qui', 'Quo', 'Qua' assegna x = 'Qui', y = 'Quo', y = 'Qua');
- liste; simili alle tuple, ma modificabili (es: x = [1, 2, 3]; y = [9, 8, 7, 6]; z = x + y assegna z = [1, 2, 3, 9, 8 ,7, 6]));
- dizionari, cioé array associativi / hash map / hash table (es: x = {'Qui' : 1, 'Quo' : 2, 'Qua' : 3}; x['Quo'] restituisce 2;
- set; simili alle liste, ma contengono valori unici e non ordinati, e inoltre supportano le operazioni su insiemi (unione, differenza simmetrica, intersezione, ecc.).
- decimali (valori in virgola fissa illimitati).

Per intanto ti ringrazio.
Mi sa che non sono mica tanto diversi alla fine allora.
Guarda qui:

var sorgente = new string[] { "bimbo", "Brutto", "Cattivo", "ﺹﻀﻏﻖﺦﺬﺡﺴ" };
var pippolone=string.Join(",", sorgente );

var Tupla=new{ Nome = "Pippo", age = 15 };
string PippoName=Tupla.Nome;
int PippoAge=Tupla.age;

int[] int1=new[]{1,2,3,4};
var int2=new[]{5,6,7,7};
var insieme=int1.Union(int2);

Poi mi sono divertito con l'insieme:

            var quanti = insieme.Count();
            var qualigrossi = insieme.Where( u => u>3);
            int quantigrossi = qualigrossi.Count();
            var alcontrario = insieme.Reverse();
            var piuuno = insieme.Select( u=>u+1 );
            var diversi = insieme.Distinct();
            bool celo = insieme.Contains(2);
            var manca = !insieme.Contains(9);
            int sommone = insieme.Sum();
            var soloiprimi5 = insieme.Take(5);
            int dammiquesto = int1.Single(y => (y > 4) && (y < 6));

            var comuni = int1.Intersect(int2);
            var subtract=int1.Where(t => !int2.Contains(t));

Poi ho visto che tu hai citato le operazioni su insieme, e io ho trovato in libreria la Intersect e la Union, ma non la Subtract (che li' sopra ho fatto con quella Where)
A questo punto, aggiungendo una funzione alla classe generica "array di interi" (penso che sia un concetto simile alla decorazione di cui accennavi)
ho potuto scrivere anche

var oracelho=int1.MenoSoloPerInt(int2);

Poi, visto che mi rompeva alquanto avere sto metodo solo per gli "Array di interi", allora l'ho esteso a quasiasi tipo di array. Il codice dei 2 estensori e' bruttino, ma lo metto qui per libreria.

public static int[] MenoSoloPerInt(this int[] daquesti, int[] togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t)).ToArray();
}

public static IEnumerable<T> Meno<T>(this IEnumerable<T> daquesti, IEnumerable<T> togliquesti)
{
    return daquesti.Where(t => !togliquesti.Contains(t));
}

Sul fatto di passare "funzioni" ad altre funzioni, anche senza delegate, lo puoi vedere dal codice divertimento che ho scritto sopra. In C# si chiamano lambda function.

I dictionary ci sono, per implementare le Hashtable tipizzate.
Ci sono anche i SortedDictionary per resituire velocemente le chiavi ordinate (quando servono), le LookUp che sono Dictionary con solo le chiavi, e altre.

Conti fatti restano fuori gli interi lunghi e i virgola fissa lunghi (e magari altri che non hai citato) pero' ammetti che non si usano poi cosi' spesso. E soprattutto non fanno uso del coprocessore (molto probabilmente) quindi non saranno neppure molto performanti. Spero che gli interi normali si differenzino da questi.

Pero' potrei mettere sul tavolo ancora una trentina (non esagero) di funzioni come le Where, Union, etc. di cui sopra, gia' in libreria e pronti all'uso, da applicare su oggetti enumerabili come le liste, etc.
Se poi ci si mette si puo' scrivere anche qualcosa di molto carino, che sembra quasi SQL.

Finisco dicendo che l'uso della keyword var lo limiterei proprio solo dove non se ne puo' fare a meno,
ovvero dopo le creazioni al volo di oggetti di una classe senza nome (Come la Tupla di prima),
oppure a seguito della restituzione di oggetti "anonimi" da funzioni che usano i generici.
In pratica io sopra avrei esplicitato quasi tutte le dichiarazioni, ma solo perche' in seguito mi piace leggere le cose in quel modo. Il risultato sarebbe stato lo stesso.