string variabileTipoStringa = string.empty;
int variabileTipoIntero = 123;
 
// Assegnazione semplice
variabileTipoStringa = "ciccio" + " " + "cappccio ha " + variabileTipoIntero.ToString + "\n";
 
// Assegnazione formattata
variabileTipoStringa = string.Format("{0} {1} ha {2}", ciccio", "cappccio", variabileTipoIntero);
 
// Assegnazione con caratteri di controllo e speciali, uso della @
variabileTipoStringa = @"rigo uno
rigo due
rigo tre";
variabileTipoStringa = @"rigo uno\r\nrigo due\r\nrigo tre";

string variabileTipoStringa = string.empty;
int variabileTipoIntero = 123;
private class Persona
{
    public string Nome => "Nome, attributo di default";
    public string Cognome {get; set;}
}
Persona tizio = new Persona()
{
   Cognome = "zighine"
};
// Assegnazione con stampa di valori da variabili in questo ambito\scope, uso della $ ad inizio stringa e {}
variabileTipoStringa = $"Numero {variabileTipoIntero}.";
variabileTipoStringa = $"{tizio.Nome} ha il numero {variabileTipoIntero}.";

DateTime OrderDate = new DateTime(2018, 5, 22); // 22/05/2018

DateTime sourceTimeStamp = DateTime.MinValue;

using System.Data.SqlTypes;
//..
DateTime sourceTimeStamp = SqlDateTime.MinValue.Value;

using System.Data.SqlTypes;
//..
List<TipologiaPiatti> elencoGruppiPiatti = new List<TipologiaPiatti>();
 
rotazioniItChef.Add(new RotazioniAttiveData()
{
  id_rotazione = 1,
  revisione_rotazione = 1,
  descrizione_rotazione = TipoImpiantoEnum.CUCE.ToString(),
  durata_rotazione = 28,
  giorno_inizio_rotazione = 1,  // Lunedì
  giorno_fine_rotazione = 0,    // Domenica
  data_inizio_rotazione = SqlDateTime.MinValue.Value.ToString("dd/MM/yyyy"),
  data_fine_rotazione = SqlDateTime.MaxValue.Value.ToString("dd/MM/yyyy"),
});

        public enum SearchModeEnum
        {
            [Description("%")]
            LIKE = 0,
            [Description("=")]
            EQUAL = 1
        }
 
        public enum SortDirectionEnum
        {
            [Description("Ascendente")]
            ASC = 0,
            [Description("Discendente")]
            DESC = 1
        }

using System;
using System.Collections.Generic;
 
class Program
{
    static void Main()
    {
	// Example Dictionary again
	Dictionary<string, int> d = new Dictionary<string, int>()
	{
	    {"cat", 2},
	    {"dog", 1},
	    {"llama", 0},
	    {"iguana", -1}
	};
	//Oppure:
	d.Add("Gallina", 3);
	d.Add("Gallo", 4);
 
	// Loop over pairs with foreach
	foreach (KeyValuePair<string, int> pair in d)
	{
	    Console.WriteLine("{0}, {1}",
		pair.Key,
		pair.Value);
	}
 
	//Assegnazione usando la chiave 'Gallo'
	d["Gallo"] = 44;
	//Output valore
	Console.WriteLine("Id del Gallo = {0}", d["Gallo"]);
 
	// Use var keyword to enumerate dictionary
	foreach (var pair in d)
	{
	    Console.WriteLine("{0}, {1}",
		pair.Key,
		pair.Value);
	}
    }
}

public struct DocumentType
{
     public static string HearingHaidSaleOrderCode = "SA";
 
     public static string LightSaleOrderCode = "LS";
 
     public static string RepairOrderCode = "RE";
}

decimal amount = 10.01M;
// che è meglio di scrivere:
decimal amount1 = decimal.Parse("10.02");

float reliability = 1.0f;

        ShipPackage[] m_shipPackages = new ShipPackage[]
        {
            new ShipPackage { ShipFullCode = "C_AT", PackageFileNameFullPath = "D:\\KT\\C_AT_20160518_1619", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_CL", PackageFileNameFullPath = "", ErrorDescription = "E' scoppiato un capicazz" },
            new ShipPackage { ShipFullCode = "C_DE", PackageFileNameFullPath = "D:\\KT\\C_DE_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_DI", PackageFileNameFullPath = "D:\\KT\\C_DI_20160518_1619", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_FA", PackageFileNameFullPath = "C:\\KT\\C_FA_20160518_1620", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_FS", PackageFileNameFullPath = "", ErrorDescription = "Sèèè e mo lo volevi no?" },
            new ShipPackage { ShipFullCode = "C_LU", PackageFileNameFullPath = "D:\\KT\\C_LU_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_MD", PackageFileNameFullPath = "D:\\KT\\C_MD_20160518_1619", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_PA", PackageFileNameFullPath = "C:\\KT\\C_PA_20160518_1620", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "C_NR", PackageFileNameFullPath = "D:\\KT\\C_NR_20160518_1621", ErrorDescription = "" },
            // No Serena e Vittoria                                                                        
 
            new ShipPackage { ShipFullCode = "A_AU", PackageFileNameFullPath = "D:\\KT\\A_AU_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "A_BE", PackageFileNameFullPath = "D:\\KT\\A_BE_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "A_CA", PackageFileNameFullPath = "D:\\KT\\A_CA_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "A_DV", PackageFileNameFullPath = "D:\\KT\\A_DV_20160518_1621", ErrorDescription = "" },
            new ShipPackage { ShipFullCode = "A_LU", PackageFileNameFullPath = "D:\\KT\\A_LU_20160518_1622", ErrorDescription = "" }
            //NO ETC
        };
 
// ... segue pezzo di codice per la ricerca mediante LinQ
var shipPackage = m_shipPackages.FirstOrDefault((p) => p.ShipFullCode == id);
 
// Oppure:
            ShipPackage[] arr_shipPackages;
            arr_shipPackages = m_shipPackages.Where((p) => p.ShipFullCode == id).ToArray<ShipPackage>();

int _number;
public int Number
{
	get
	{
		return this._number;
	}
	set
	{
		this._number = value;
	}
}

public static string PublicClientId
{
    get;
    private set;
}

private void businessAPINoah_BusinessAPIEvent(IBusinessAPIEventArg arg)
{
    log.InfoFormat("Init. arg = '{0}'", arg?.ToString() ?? "NULL");
    // ... etc

public class MiaClasse
{
    public MiaClasse() // Costruttore. Scorciatoia di creazione: digitare ctor e poi TAB
    {
    }
}

public class ClassePadre
{
    public ClassePadre() 
    {
    }
}
 
public class ClasseSpecializzata : ClassePadre
{
    public ClasseSpecializzata() 
           : ClassePadre() // <-- Esecuzione del costruttore padre prima di quella figlio specializzata
    {
    }
}

class Building
{
    public BuildingType BuildingType { get; protected set; }
    public string Address { get; set; }
    public decimal Price { get; set; }
 
    public Building() : this("Unknown", 0m)
    {
    }
 
    public Building(string address, decimal price)
    {
        BuildingType = BuildingType.General;
        Address = address;
        Price = price;
    }
}
//-----------------------
class Office : Building
{
    public string Company { get; set; }
 
    public Office() : this(null, 0m, null)
    {
    }
 
    public Office(string address, decimal price, string company)
        : base(address, price)
    {
        Company = company;
        BuildingType = BuildingType.Office; // Don't wanna repeat statement
    }
}

string strValue = "xxx";
switch (strValue)
{
	case "Caso 1":
	case "Caso 2":
	case "Caso 3":
		Console.Write("Caso 1,2,3");
		break;
	case "Caso 4":
		Console.Write("Caso 4, 6?");
		break;
	case "Caso 5":
		Console.Write("Caso 4");
		break;
	case "Caso 6":
                goto case "Caso 4"; // ATTENZIONE goto per condividere un caso
	case "Caso ok":
		return true;
	default:
		// Quando si verifica un caso imprevisto
		return false; // Esce dal Metodo con esito falso!
}

for (int i = 1; i <= 5; i++)
{
	Console.WriteLine(i);
}

foreach (GridViewRow gvrow in coll) // PER OGNI ship Position
{
	...
	break; // Esce dal foreach
	...
	continue; // Va all'item successivo
	...
	return; // Esce dalla procedure\function
}

int n = 1;
while (n < 6) 
{
     Console.WriteLine("Current value of n is {0}", n);
     n++;
     // break; // <--- esce dal ciclo while !
}

int i = 0;
 
do
{
    //Operazioni con l'indice i
    // ... etc ...
    i++;
} while (i < 7);

using System.Configuration;
...
// Usandola come segue
var connectionString=ConfigurationManager.ConnectionStrings["DB_UNO"].ConnectionString;

DataTable result = null;
SqlCommand sqlcmd = new SqlCommand(query, connection);
sqlcmd.CommandTimeout = 120; // SECONDI !
SqlDataAdapter sqlda = new SqlDataAdapter(sqlcmd);
result = new DataTable();
sqlda.Fill(result);

string strFullPath = string.Empty;
strFullPath = Path.Combine(strPath, strXMLFileName);
 
DataSet ds = Manager.CreateItemDataSet();
 
ds.WriteXml(strFullPath);	// Scrittura del File XML. Sovrascrive il file già esistente
 
//LETTURA:
ds.ReadXml(strFullPath);

//...
using System.Data;
//...
private static DataTable CreateAndPopulate_Table()
{
    // Creazione
    DataTable table = new DataTable();
    table.Columns.Add("Weight", typeof(int));
    table.Columns.Add("Name", typeof(string));
    table.Columns.Add("Breed", typeof(string));
    table.Columns.Add("Date", typeof(DateTime));
 
    // Aggiunta di 5 DataRows.
    table.Rows.Add(57, "Koko",    "Shar Pei",               DateTime.Now);
    table.Rows.Add(130, "Fido",   "Bullmastiff",            DateTime.Now);
    table.Rows.Add(92, "Alex",    "Anatolian Shepherd Dog", DateTime.Now);
    table.Rows.Add(25, "Charles", "Cavalier King Charles Spaniel", DateTime.Now);
    table.Rows.Add(7, "Candy",    "Yorkshire Terrier",      DateTime.Now);
    return table;
}

public static DataSet CreateItemDataSet()
{
	DataSet dsDBIndex_BankPassword = new DataSet(m_DSName_DBBP);
	DataTable dtIndex_BankPassword = new DataTable(m_TBName_IndxBP);
 
	dtIndex_BankPassword.Columns.Add("FileName", typeof(string));
	dtIndex_BankPassword.Columns.Add("WebSite", typeof(string));
	dtIndex_BankPassword.Columns.Add("Person", typeof(string));
	dtIndex_BankPassword.Columns.Add("Is4Work", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsSecret", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsComputerResource", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsSubscription", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsBank", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsECommerce", typeof(bool));
	dtIndex_BankPassword.Columns.Add("IsTVStreaming", typeof(bool));
	dtIndex_BankPassword.Columns.Add("TAG4Search1", typeof(string));
	dtIndex_BankPassword.Columns.Add("TAG4Search2", typeof(string));
	dtIndex_BankPassword.Columns.Add("DtInsert", typeof(DateTime));
	dtIndex_BankPassword.Columns.Add("DtLastUpdate", typeof(DateTime));
 
	dsDBIndex_BankPassword.Tables.Add(dtIndex_BankPassword);
	return dsDBIndex_BankPassword;
}
 
public static void AddNewItem_BP(ref DataSet ds, Item_BP newItem)
{
	DataRow dr = ds.Tables[m_TBName_IndxBP].NewRow();
	dr["FileName"] = newItem.FileName;              //string
	dr["WebSite"] = newItem.WebSite;
	dr["Person"] = newItem.Person;
	dr["Is4Work"] = newItem.Is4Work;                //bool
	dr["IsSecret"] = newItem.IsSecret;
	dr["IsComputerResource"] = newItem.IsComputerResource;
	dr["IsSubscription"] = newItem.IsSubscription;
	dr["IsBank"] = newItem.IsBank;
	dr["IsECommerce"] = newItem.IsECommerce;
	dr["IsTVStreaming"] = newItem.IsTVStreaming;
	dr["TAG4Search1"] = newItem.TAG4Search1;
	dr["TAG4Search2"] = newItem.TAG4Search2;	
	dr["DtInsert"] = newItem.DtInsert;              //DateTime
	dr["DtLastUpdate"] = newItem.DtLastUpdate;
 
	ds.Tables[m_TBName_IndxBP].Rows.Add(dr);
}

public DataTable MakeDataTable(){
 
    DataTable myTable;
    DataRow myNewRow;
    // Create a new DataTable.
    myTable = new DataTable("My Table");
 
    // Create DataColumn objects of data types.
    DataColumn colString = new DataColumn("StringCol");
    colString.DataType = System.Type.GetType("System.String");
    myTable.Columns.Add(colString);
 
    DataColumn colInt32 = new DataColumn("Int32Col");
    colInt32.DataType = System.Type.GetType("System.Int32");
    myTable.Columns.Add(colInt32);
 
    DataColumn colBoolean = new DataColumn("BooleanCol");
    colBoolean.DataType = System.Type.GetType("System.Boolean");
    myTable.Columns.Add(colBoolean);
 
    DataColumn colTimeSpan = new DataColumn("TimeSpanCol");
    colTimeSpan.DataType = System.Type.GetType("System.TimeSpan");
    myTable.Columns.Add(colTimeSpan);
 
    DataColumn colDateTime = new DataColumn("DateTimeCol");
    colDateTime.DataType = System.Type.GetType("System.DateTime");
    myTable.Columns.Add(colDateTime);
 
    DataColumn colDecimal = new DataColumn("DecimalCol");
    colDecimal.DataType = System.Type.GetType("System.Decimal");
    myTable.Columns.Add(colDecimal);
 
    DataColumn colByteArray = new DataColumn("ByteArrayCol");
    colByteArray.DataType = System.Type.GetType("System.Byte[]");
    myTable.Columns.Add(colByteArray);
 
    // Populate one row with values.
    myNewRow = myTable.NewRow();
 
    myNewRow["StringCol"] = "Item Name";
    myNewRow["Int32Col"] = 2147483647;
    myNewRow["BooleanCol"] = true;
    myNewRow["TimeSpanCol"] = new TimeSpan(10,22,10,15,100);
    myNewRow["DateTimeCol"] = System.DateTime.Today;
    myNewRow["DecimalCol"] = 64.0021;
    myNewRow["ByteArrayCol"] = new Byte[] { 1, 5, 120 };
    myTable.Rows.Add(myNewRow);
    return myTable;
 }

DataTable table = GetTable();
DataRow row = table.Rows[0];
Console.WriteLine(row["Breed"]);
//
// Get the last row in the DataTable.
//
DataRow last = table.Rows[table.Rows.Count - 1];
Console.WriteLine(last["Breed"]);

if (dr.Table.Columns.Contains("source")) // Questo non fa scattare eccezione ma NON VA BENE!!!
{
	result.Source = dr["source"] as string;
}
//Altro esempio per verifica con coalesce:
string strpercorso = dr.Table.Columns.Contains("ArchiveDocPath") 
                         ? null
                         : dr["ArchiveDocPath"].ToString();

FrmPopUpShipInfo popUp = new FrmPopUpShipInfo();
popUp.Logger4Popup = m_loggerForm;
popUp.ShipFullCode = shipFullCode;
 
popUp.ShipCode = shipCode;
popUp.CompanyCode = companyCode;
 
DataView dvSourceOneShip = new DataView(m_DtAllShipHelp);
DataView dvSourceAllShip = new DataView(m_DtAllShipHelp);
 
dvSourceOneShip.RowFilter = string.Format("key = '{0}'", shipFullCode);
dvSourceAllShip.RowFilter = string.Format("CompanyCode = '{0}'", companyCode);
 
popUp.BindingSrcOneShip.DataSource = dvSourceOneShip;
popUp.BindingSrcAllShip.DataSource = dvSourceAllShip;
 
popUp.ShowDialog();

DataTable dtOoutfiltered =  m_DtAllShipHelp.Select(string.Format("key = '{0}'", shipFullCode))
                                                        .CopyToDataTable();

/// <summary>
/// Trasforma un DataTable in un altro con righe che diventano colonne e viceversa.
/// utile per trasformare la visualizzazione in un griglia
/// </summary>
/// <param name="dtToTranspose">DataTable di origine</param>
/// <returns>DataTable trasposto</returns>
public static DataTable TransposeDataTable(DataTable dtToTranspose)
{
	DataTable transposedTable = new DataTable();
 
	DataColumn firstColumn = new DataColumn(dtToTranspose.Columns[0].ColumnName);
	transposedTable.Columns.Add(firstColumn);
 
	// La prima riga diventa la prima colonna di intestazione
	for (int i = 0; i < dtToTranspose.Rows.Count; i++)
	{
		DataColumn dc = new DataColumn(dtToTranspose.Rows[i][0].ToString());
		transposedTable.Columns.Add(dc);
	}
 
	for (int j = 1; j < dtToTranspose.Columns.Count; j++)
	{
		DataRow dr = transposedTable.NewRow();
		dr[0] = dtToTranspose.Columns[j].ColumnName;
 
		for (int k = 0; k < dtToTranspose.Rows.Count; k++)
		{
			dr[k + 1] = dtToTranspose.Rows[k][j];
		}
		transposedTable.Rows.Add(dr);
	}
	return transposedTable;
}

List<Alarm> alarms = new List<Alarm>();
 
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandType = System.Data.CommandType.Text;
string qrySQL = @"SELECT 
				* FROM Alarms with(nolock)
				WHERE 1=1";
 
using (SqlDataReader reader = command.ExecuteReader())
{
	while (reader.Read())
	{
		Alarm alarm = new Alarm();
		//Stralcio di acquisizione		
 
		alarm.Acknowledged = (Boolean)reader["Acknowledged"];
		alarm.AcknowledgeDate = DateHelper.SpecifyUtcKind(reader["AcknowledgeDate"] as DateTime?);
		alarm.ShipCode = reader["ShipCode"] as string;
		alarm.Segment1Id = reader["Segment1Id"] as Guid?;
		alarm.GeoPosition = reader["GeoPosition"] as SqlGeometry;
		alarm.Id = (Guid)reader["Id"];
 
		// Metodo alternativo a sopra --^
		//--------------------------------------------------
		alarm.Acknowledged = reader["Acknowledged"].AsBool();
        alarm.ShipCode = reader["ShipCode"].AsString(),
        alarm.IntValueEx = reader["IntValueEx"].AsInt(),
        alarm.AcknowledgeDate = reader["AcknowledgeDate"].AsDateTime(),
        alarm.Id = reader["Id"].AsGuid(),
		//------- ATTENZIONE, esempio in caso la query sul DB non restituisca il campo indipendentemente dal suo contenuto
        alarm.CampoOPZIONALE = reader.FieldExists("CAMPO_NON_IN_SELECT") 
                                    ? reader["CAMPO_NON_IN_SELECT"].AsInt() 
                                    : -1,
		//--------------------------------------------------
 
		alarms.Add(alarm);
	}
}

using (SqlConnection sqlConn = new SqlConnection(connectionString)) {
	using (SqlCommand cmd = new SqlCommand("sp_Add_contact", sqlConn)) {
	  cmd.CommandType = CommandType.StoredProcedure;
 
	  cmd.Parameters.Add("@FirstName", SqlDbType.VarChar).Value = txtFirstName.Text;
	  cmd.Parameters.Add("@LastName", SqlDbType.VarChar).Value = txtLastName.Text;
 
	  sqlConn.Open();
	  cmd.ExecuteNonQuery();
          sqlConn.Close();
	}
}

        /// <summary>
        /// Crea una lista di SqlParameter da un semplice Dictionary. Ogni parametro avrà direzione input.
        /// </summary>
        /// <param name="parameters"></param>
        /// <returns></returns>
        private static List<SqlParameter> SetupParameters(Dictionary<string, object> parameters)
        {
            List<SqlParameter> result = new List<SqlParameter>();
 
            if (parameters != null && parameters.Count > 0)
            {
                foreach (String parName in parameters.Keys)
                {
                    Object parValue = null;
                    SqlParameter sqlpar = null;
 
                    sqlpar = new SqlParameter();
                    sqlpar.ParameterName = parName;
                    sqlpar.Direction = ParameterDirection.Input;
                    parValue = parameters[parName];
 
                    if (parValue != null)
                    {
                        sqlpar.Value = parValue;
                        if (parValue.GetType() == typeof(SqlGeometry))
                        {
                            sqlpar.SqlDbType = System.Data.SqlDbType.Udt;
                            sqlpar.UdtTypeName = "geometry";
                        }
                    }
                    else 
                       sqlpar.Value = DBNull.Value;
 
                    result.Add(sqlpar);
                }
            }
            return result;
        }

if (parValue.GetType() == typeof(SqlGeometry))

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
 
namespace TestEreditarieta
{
    class Program
    {
        #region Classi della famiglia
        public class Cls_A_Padre
        {
            // La seguente Property potrebbe essere omessa ma E' UTILISSIMA per 
            // DISCERNERE DIRETTAMENTE IL TIPO DELLA CLASSE ESTESA !!!
            public EnumTipo flagTipo
            {
                get;
                set;
            }
            public string A_Uno
            {
                get;
                set;
            }
            public string A_Due
            {
                get;
                set;
            }
        }
        public class Cls_B_Figlio : Cls_A_Padre
        {
            public string B_Uno
            {
                get;
                set;
            }
            public string B_Due
            {
                get;
                set;
            }
        }
        public class Cls_C_Figlio : Cls_A_Padre
        {
            public string C_Uno
            {
                get;
                set;
            }
            public string C_Due
            {
                get;
                set;
            }
        }
        #endregion
 
        public enum EnumTipo
        {
            B = 0,
            C = 1
        }
 
        static void Main(string[] args)
        {
            Cls_A_Padre generica = Inizializza(EnumTipo.C);
 
            Type myObjectType = generica.GetType(); // typeof(generica);
 
            IList<PropertyInfo> props = new List<PropertyInfo>(myObjectType.GetProperties());
 
            foreach (PropertyInfo prop in props)
            {
                object propValue = prop.GetValue(generica, null);
 
                Console.WriteLine("Valore = {0}, tipo {1}", propValue.ToString(), propValue.GetType());
            }
 
            Console.ReadLine();
        }
 
        private static Cls_A_Padre Inizializza(EnumTipo flagTipo)
        {
            Cls_A_Padre objIstanziato = new Cls_A_Padre();
            objIstanziato.A_Uno = "1aa";
            objIstanziato.A_Due = "2aa";
 
            switch (flagTipo)
            {
                case EnumTipo.B:
                    Cls_B_Figlio objB = new Cls_B_Figlio();
                    objB.A_Uno = "1a";
                    objB.A_Due = "2a";
                    objB.B_Uno = "1b";
                    objB.B_Due = "2b";
                    objIstanziato = objB;
                    break;
                case EnumTipo.C:
                    Cls_C_Figlio objC = new Cls_C_Figlio();
                    objC.A_Uno = "1a";
                    objC.A_Due = "2a";
                    objC.C_Uno = "1c";
                    objC.C_Due = "2c";
                    objIstanziato = objC;
                    break;
                default:
                    break;
            }
 
 
            return objIstanziato;
        }
    }
}

public interface IEsempio
{
  void Metodo1();
  bool Metodo2();
 
  string Proprieta1 { get; set; }
  int Proprieta2 { get; }
}

public class Esempio : IEsempio
{
  public void Metodo1()
  {
    //...
  }
 
  public bool Metodo2() { return true; }
 
  public string Proprieta1
  {
    get { return string.Empty; }
    set { /*...*/ }
  }
 
  public int Proprieta2
  {
    get { return 0; }
  }
}

public abstract class Figura
{
  // Attribti
  protected string m_Nome;
  protected int m_NumeroLati;
 
  // Costruttore
  public Figura(string nome, int numeroLati)
  {
    m_Nome = nome;
    m_NumeroLati = numeroLati;
  }
 
 
  #region Properties
  public string Nome
  {
    get 
     { return m_Nome; }
  }
 
  public int NumeroLati 
  { 
    get 
     { return m_NumeroLati; }
  }
 
//Properties astratte
  public abstract double Perimetro 
   { get; }
  public abstract double Area 
   { get; }
  #endregion
 
  #region Metodi
  // Eventuali metodi con azioni sicuramente comuni a tutte le classi che saranno derivate
 
  // Metodi ASTRATTI
  public abstract void Disegna(); // <-- notare che i metodi astratti non prevedono implementazione
  #region
}

public class Quadrato : Figura
{
  private double m_Lato;
 
  // Costruttore che eredita dal costruttore base ed aggiunge un argomento
  public Quadrato(int lato) : base("Quadrato", 4)
  {
    m_Lato = lato;
  }
 
  // Proprietà (definite nella classe astratta) che DEVONO essere sovrascritte
  public override double Perimetro
  {
    get { return m_Lato * 4; }
  }
 
  public override double Area
  {
    get { return m_Lato * m_Lato; }
  }
 
  // Metodo che DEVE essere sovrascritto
  public override void Disegna()
  {
    //…
  }
}

public Point Move(int dx, int dy) => new Point(x + dx, y + dy); 
 
public void Print() => Console.WriteLine(First + " " + Last); 
// ^-- Works with operators, properties, and indexers too. public static Complex operator 
// +(Complex a, Complex b) => a.Add(b); public string Name => First + " " + Last; 
// public Customer this[long id] => store.LookupCustomer(id);

Using System;
 
delegate void CambiaNumero(int n);
namespace DelegateAppl
{
   class TestDelegate
   {
      static int num = 10; // Variabile STATICA su cui agiranno TUTTI i metodi delegati nominativi e non
      public static void AddNum(int p)
      {
         num += p;
         Console.WriteLine("Metodo nominativo 'AddNum': {0}", num);
      }
 
      public static void MultNum(int q)
      {
         num *= q;
         Console.WriteLine("Metodo nominativo 'MultNum': {0}", num);
      }
 
      public static int getNum()
      {
         return num;
      }
      static void Main(string[] args)
      {
         // Crea un istanza del delegato usando il seguente Metodo ANONIMO
         CambiaNumero istanzaMetodiDelegatiCN = delegate(int x)
         {
            Console.WriteLine("Metodo anonimo: {0}", x);
         };
 
         istanzaMetodiDelegatiCN(10); // Chiama il delegato usando il metodo anonimo di prima
 
         istanzaMetodiDelegatiCN =  new CambiaNumero(AddNum); // Istanzia il Delegato passandogli il metodo nominativo da eseguire
 
         istanzaMetodiDelegatiCN(5); // Esegue il delegato usando il metodo nominativo 
 
         istanzaMetodiDelegatiCN =  new CambiaNumero(MultNum); //Istanzia il Delegato usando un altro il metodo nominativo 
 
         istanzaMetodiDelegatiCN(2); // Esegue il delegato usando il metodo nominativo 
         Console.ReadKey();
      }
   }
}

// Use of ..
string strIn = MyClass.GetNextId("CU_B_CUSTOMER_ENTITLEMENT_DETAIL_EXT_NZL", 
                                                            fieldName: "COUNTER", 
                                                            shopCode: "*", 
                                                            laptopCode: "*")
 
//----------- Called class:
public class MyClass
{
     public string GetNextId(string tableName, 
						string fieldName, 
						string companyCode = null, 
						string divisionCode = null, 
						string shopCode = null, 
						string laptopCode = null, 
						string userUpdate = null, 
						DateTime? dateConstraint = null, 
						string resultPrefix = null)
	{
		// ....
 
		return strOut;
	}
}

dynamic contact = new ExpandoObject();
contact.Name = “Patrick Hines”;
contact.Phone = “206-555-0144”;
 
contact.Address = new ExpandoObject();
contact.Address.Street = “123 Main St”;
contact.Address.City = “Mercer Island”;
contact.Address.State = “WA”;
contact.Address.Postal = “68402”;

dynamic contacts = new List<dynamic>();
contacts.Add(new ExpandoObject());
contacts[0].Name = “Patrick Hines”;
contacts[0].Phone = “206-555-0144”;
contacts.Add(new ExpandoObject());
contacts[1].Name = “Ellen Adams”;
contacts[1].Phone = “206-555-0155”;

public class BaseClass
{
    public virtual int CustomerID {get; set;}
 
    public void printname()
    {
       CustomerID = 1;
       CustomerID.Dump();
    }
}
 
public class DerivedClass : BaseClass
{
    public new string CustomerID {get; set;}
 
    public void PrintCustomerID()
    {
        CustomerID = "jshwedeX"; 
        CustomerID.Dump();
    }
}

using System;
 
namespace wildert
{
    public class Metronome
    {
        public event TickHandler EventoTicchettio;
        public EventArgs e = null;
        public delegate void TickHandler(Metronome m, EventArgs e);
 
        public void Start()
        {
            while (true)
            {
                System.Threading.Thread.Sleep(3000);
                // E' stato assegnato un Handler per l'evento ?
                if (EventoTicchettio != null) 
                {
                    // Scatena l'evento
                    EventoTicchettio(this, e);
                }
            }
        }
    }
    public class Listener
    {
        public void Subscribe(Metronome m)
        {
            m.EventoTicchettio += new Metronome.TickHandler(HandlerAscoltaIlTicchettio);
        }
        private void HandlerAscoltaIlTicchettio(Metronome m, EventArgs e)
        {
            System.Console.WriteLine("Evento 'sono in ascolto' è stato scatenato");
        }
 
    }
    class Test
    {
        static void Main()
        {
            Metronome m = new Metronome();
            Listener l = new Listener();
            // Quanto segue si esegue solo la prima volta per sottoscrivere l'evento e far puntare al relativo handler
            l.Subscribe(m); 
            m.Start();
        }
    }
}

namespace ClassiLibreria
{
    public class UADataSubscriptionHandlers
    {
	// Risorse
        public static event MDERestartHandler MDERestartEvent;
        public static EventArgs e = null;
        public delegate void MDERestartHandler(UADataSubscriptionHandlers s, EventArgs e);
 
	//... etc
 
	// Metodo che genererà l'evento
	public static void GeneraEventoDaIntercettare()
	{
		// Se nella classe client è stato previsto metodo di handling, vedi: UADataSubscriptionHandlers_MDERestartEvent
		if (MDERestartEvent != null) 
		{
			MDERestartEvent(new UADataSubscriptionHandlers(), e); // <-- Ciò scatenerà l'evento !!!
		}		
	}
     }	
}

using ClassiLibreria;
 
namespace ClassiClient
{
	public class ClasseClient
	{
		public ClasseClient() // Costruttore
		{
			// ... inizializzazioni varie
 
			// Aggancio un metodo ad hoc in questa classe che gestisca l'evento generato:
			UADataSubscriptionHandlers.MDERestartEvent += UADataSubscriptionHandlers_MDERestartEvent;
		}
 
		// etc
 
        	private void UADataSubscriptionHandlers_MDERestartEvent(UADataSubscriptionHandlers s, EventArgs e)
        	{
            		IsStarted = false; // Per uscire da un ciclo WHILE e passare al WatchDog
            		m_logger.Warn(string.Format("IsStarted = false; SecondsTillShutdown {0}", UACore.SrvMDEInfo.SecondsTillShutdown));
        	}		
	}
}

    public class ListEventArgs : EventArgs
    {
        public List<string> Data { get; set; }
        public ListEventArgs(List<string> data)
        {
            Data = data;
        }
    }

public event EventHandler<ListEventArgs> NewFileAdded;

protected void OnNewFileAdded(List<string> data)
{
    var localCopy = NewFileAdded;
    if (localCopy != null)
    {
        localCopy(this, new ListEventArgs(data));
    }
}

myObj.NewFileAdded += new EventHandler<ListEventArgs>(myObj_NewFileAdded);

public void myObj_NewFileAdded(object sender, ListEventArgs e)
{
       // Do what you want with e.Data (It is a List of string)
}

public class Generica<T> 
{
   public T campo;
   ...
}

Generica<string> g = new Generica<string>();

Generica<int> g = new Generica<int>();

Generica<string> g = new Generica<string>();

public class Generica
{
   public Stringa campo;
   ...
}

public T Somma<T>(T a, T b);

public class Stack< T >
{
   T[] elements;
   int count;
 
   public void Push(T item) 
   {
      ...
   }
 
   public T Pop() 
   {
      ...
   }
}

public void Swap<T>(ref T a, ref T b) 
{ 
   T temp; 
   temp = a; 
   a = b; 
   b = temp; 
} 
 
// ..
public delegate void DelegatoGenerico<T>(object oggetto, T datievento);

public static class Extensions
{
	/// <summary>
	/// Data una stringa estrae a partire dall'inizio i primi n caratteri, 
	/// se la lunghezza è m minore n estrarrà solo i primi m caratteri
	/// es.:    miaStringa.SubStringMin(11)
	/// </summary>
	/// <param name="text"></param>
	/// <param name="n"></param>
	/// <returns></returns>
	public static string SubStringMin(this string text, int n)
	{
		int lenMinOut = 0; // text.Length;
		string strOut = string.Empty;
		if (!string.IsNullOrWhiteSpace(text))
		{
			if (text.Length < n)
			{
				lenMinOut = text.Length;
			}
			else
			{
				lenMinOut = n;
			}
			strOut = text.Substring(0, lenMinOut);
		}
		return strOut;
	}
}

public static class Extensions
{
	public static int GetWeekOfYear(this DateTime date)
	{
		GregorianCalendar cal = new GregorianCalendar(GregorianCalendarTypes.Localized);
		return cal.GetWeekOfYear(date, CalendarWeekRule.FirstDay, DayOfWeek.Monday);
	}
}

  if (s == null)
    throw new ArgumentNullException("s");