Sto approcciandomi per la prima all’utilizzo del componente ListView, nettamente più potente e flessibile (soprattutto in termini di personalizzazione del layout) rispetto al GridView.

Seguendo l’esempio di Scott Gu, ho creato un ListView del tipo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<asp:ListView runat="server" ID="temp">
  <LayoutTemplate>
  <table>
    <asp:PlaceHolder ID="itemContainer" runat="server">
    </asp:PlaceHolder>
  </table>
  </LayoutTemplate>
 
  <ItemTemplate>
  <tr>
    <td>
      <%#Eval("Descrizione") %>
    </td>
  </tr>
  </ItemTemplate>
</asp:ListView>

Tuttavia, ricevo questo errore a run-time:

È necessario specificare un segnaposto di elemento nell’elemento ListView ‘temp’. Specificare un segnaposto di elemento impostando la proprietà ID di un controllo su “itemPlaceholder”. Il controllo segnaposto di elemento deve inoltre specificare runat=”server”.

Andreas Kraus suggerisce la soluzione corretta, cioè sostituire il valore itemContainer con itemPlaceHolder (nuovo valore di default dell’ ItemPlaceHolderId di ListView)

Il codice corretto, quindi, è:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<asp:ListView runat="server" ID="temp">
  <LayoutTemplate>
  <table>
    <asp:PlaceHolder ID="itemPlaceHolder" runat="server">
    </asp:PlaceHolder>
  </table>
  </LayoutTemplate>
 
  <ItemTemplate>
  <tr>
    <td>
      <%#Eval("Descrizione") %>
    </td>
  </tr>
  </ItemTemplate>
</asp:ListView>

A questo punto, tutto funziona correttamente: il controllo itemPlaceHolder viene sostituito a run-time con il contenuto esplcitato dell’ItemTemplate

Ovviamente, il valore della proprietà ID del componente asp:PlaceHolder dichiarato dentro il LayoutTemplate, è personalizzabile grazie all’attributo ItemPlaceholderID di ListView

Stavo ragionando sull’estender Fluent NHibernate per automatizzare il processo di produzione delle entità (sempre ammesso che non esista ancora nulla del genere).

Mi sono quindi posto il problema di come fare per leggere i tipi delle colonne di una tabella. Mi risponde Joe Webb sul suo blog:

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT 
   ORDINAL_POSITION
  ,COLUMN_NAME
  ,DATA_TYPE
  ,CHARACTER_MAXIMUM_LENGTH
  ,IS_NULLABLE
  ,COLUMN_DEFAULT
FROM   
  INFORMATION_SCHEMA.COLUMNS 
WHERE   
  TABLE_NAME = 'TABLE_NAME' 
ORDER BY 
  ORDINAL_POSITION ASC;

Ieri ho perso metà pomeriggio di lavoro per una mia non conoscenza del mapping delle Entity in Fluent NHibernate.

L’eccezione lanciata da NHibernate:

1

Association references unmapped class: YourClass

Il mapping delle mie Entity avviene tramite un metoto CreateSessionFactory:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

 
FluentNHibernate.Cfg.Fluently.Configure()
  .Database
    (
      FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2008
        .ConnectionString(
          c => c.Server(DbConnectionValue.Server)
                    .Username(DbConnectionValue.User)
                    .Password(DbConnectionValue.Password)
                    .Database(DbConnectionValue.Database)
          )
        .ProxyFactoryFactory("
NHibernate.ByteCode.LinFu.ProxyFactoryFactory
,NHibernate.ByteCode.LinFu")
  )
  .Mappings
  (
    m => m.FluentMappings
.AddFromAssemblyOf<OneClass.Of.My.Repository>()
  )
  .BuildSessionFactory();

Bisogna fare attenzione che esistono 2 regole affinchè si possa correttamente caricare il mapping di Entity caricate tramite il metodo AddFromAssemblyOf:

1. dichiarare sempre public le classi di mapping;
2. definire sempre le proprietà Id;

Immaginiamo di avere il seguente modello:

1
2
3
4
5
6
7
8

 
public class MyModel
{
  public string Cognome { get; set; }
  public string Nome { get; set; }
 
  public DateTime DataNascita { get; set; }
}

Immaginiamo di utilizzare questo modello per renderizzare una View. Successivamente, questa ipotetica View restituirà in post lo stesso Modello.

Una delle scelte archiettturali che si può seguire, è quella di serializzare MyModel in JSon per poi passarlo al server. Ipotizziamo, adesso, di non voler serializzare una delle proprietà di MyModel, ad esempio DataNascita. Per farlo, basta agganciare alla proprietà DataNascita, l’attributo ScriptIgnore:

1
2
3
4
5
6
7
8
9

 
public class MyModel
{
  public string Cognome { get; set; }
  public string Nome { get; set; }
 
  [ScriptIgnore]
  public DateTime DataNascita { get; set; }
}

Ipotizziamo di avere questo contratto in un servizio WCF:

1
2

[OperationContract]
string HelloWorld(string foo, int bar);

Nel caso in cui ci si agganci da client non-WCF, come ad esempio client dotnet 1.1 (o client non dotnet), ci si potrebbe trovare in una situazione come la seguente:

1
2

Service1.HelloWorld(string foo, bool fooSpecified
, int bar, bool barSpecified);

L’ultimo parametro viene aggiunto per esplicitare l’obbligatorietà del parametro int bar. Questo comportamento nasce dall’assenza dei tipi nullable (int?, bool?) nei framework dotnet pre-2.0.

Per risolvere questa problematica:
1. aggiungere l’attributo XMLSerializerFormat come contratto all’interfaccia esposta dal web service WCF;
2. aggiungere l’attributo DataContract DataMember[IsRequired=true] alla proprietà da serializzare

Ultimamente mi sono ritrovato a dover fronteggiare un problema che, in realtà, è abbastanza comune.
Immaginiamo di avere un’area generica (diciamo un div) all’interno del quale restituiamo all’utente un messaggio a seconda della specifica funzionalità che deve eseguire.

Nell’ottica del riutilizzo del codice, potrebbe essere utile cambiare il messaggio visualizzato a seconda del punto dal quale si giunge.

Per questa ragione mi son chiesto se esistesse un modo per poter associare ad un enums uno specifico valore stringa. L’enums è sicuramente utile per individuare il punto dal quale si proviene, ma da solo non è sufficientemente potente per fornire un feedback all’utente.

Mai re-inventare la ruota, quando google ti può dare una mano
Stefan Sedich fornisce un’ottima soluzione al mio problema.

1. Definire un nuovo attributo custom di classe;

public class StringValueAttribute : Attribute
{
	public string StringValue { get; set; }
 
	public StringValueAttribute(string value)
	{
		this.StringValue = value;
	}
}

2. Creare un extension method il cui obiettivo sarà quello di recuperare il valore stringa dell’attributo StringValue associato ai singoli enums;

public static class StringValueExtension
{
    public static string GetStringValue(this Enum value)
    {
        type = value.GetType();
        fieldInfo = type.GetField(value.ToString());
 
  	StringValueAttribute[] attribs = 
        fieldInfo.GetCustomAttributes(
	   typeof(StringValueAttribute), false) 
           as StringValueAttribute[];
 
	return attribs.Length > 0 ? attribs[0].StringValue : null;
    }
}

3. Creare un enums con associato un attributo StringValue.

public enum Test : int 
{
    [StringValue("a")]
    EnumsA = 1,
 
    [StringValue("b")]
    EnumsB = 2        
}

Consideriamo il caso di un’applicazione n-layered:
- strato di Presentation;
- strato di Business Logic;
- strato DAL per l’accesso ai dati sfruttando Linq to Entity;
- strato dell’ObjectModel.

All’interno di quest’ultimo creiamo un modello sfruttando le potenzialità della nuova versione di Entity Framework 4 (EF4).

Può capitare di imbattersi nel seguente errore in fase di istanziazione dell’ObjectContext e quindi di connessione al db:

Unable to load the specified metadata resource

L’errore, nel mio caso, derivava da una non corretta valorizzazione dell’attributo MetaData dell’oggetto EntityConnectionStringBuilder.

Quando Visual Studio 2010 crea il modello per voi, parte dal presupposto che la stringa di connessione non venga usata in ambiente n-layered. Per questo motivo, la stringa di connessione avrà un aspetto del tipo:

res://*/Model.csdl|res://*/Model.ssdl|res://*/Model.msl

Il problema si presenta nel momento in cui si cerca di istanziare l’ObjectContext da un altro strato dell’applicazione.

Ciò avviene perchè Res://*/ è un URI che punta alla risorsa nell’assembly corrente. Nel caso in cui, come detto, l’edmx del modello si trovi in un assembly diverso dal codice che si sta usando, res://*/ non riesce a risolvere la risorsa nella posizione corrente.

Basterà quindi specificare l’esatta posizione del Modello edmx:

res://ObjectModel/Model.csdl|res://*/
Model.ssdl|res://ObjectModel/Model.msl

(via stackoverflow)

Quando vi trovate ad utilizzare il componente asp:textbox in modalità multiline, noterete che l’attributo maxlength non funziona.

Non conosco ne conosco la ragione, però esiste un work-around:

private const int MAX_LENGTH = 100;
 
protected void Page_Load(object sender, EventArgs e)
{
string lengthFunction = "function isMaxLength(txtBox) {";
    lengthFunction += " if(txtBox) { ";
    lengthFunction += 
      "     return ( txtBox.value.length <=" + MAX_LENGTH + ");";
    lengthFunction += " }";
    lengthFunction += "}";
 
this.txtMyTextBox.Attributes.Add("onkeypress", 
      "return isMaxLength(this);");
      ClientScript.RegisterClientScriptBlock(
        this.GetType(), 
        "txtLength", 
        lengthFunction , true);
 
}

(via codegod.de)

In alcuni casi, nel realizzare un’applicazione web ha senso appoggiarsi a Microsoft Reporting Services per consentire agli utenti di stampare il risultato di una generica griglia sulla quale è possibile applicare un sorting.

Il problema è quello di riportare l’esatto sorting applicato sulla griglia anche sul report generato da Microsoft Reporting Services.

A tal fine, quindi, la strada che ho seguito è la seguente:

1. Creare due nuovi parametri all’interno del report: DIRECTION e SORTBY (parametri stringa con valore anche eguale a stringa vuota);

2. Entrare nelle proprietà della tabella Tablix, sezione ordinamento. Inserire le due seguenti espressioni:

=iif(Parameters!DIRECTION.Value="asc"
,Fields(Parameters!SORTBY.Value).Value,0)
=iif(Parameters!DIRECTION.Value="desc"
,Fields(Parameters!SORTBY.Value).Value,0)

Imporre che la prima sia un ordinamento “da A a Z” e la seconda un ordinamento “da Z ad A”

A questo punto è sufficiente impostare questi due parametri da codice c# ed il gioco è fatto

(via 15seconds.com)

In rete esistono molti esempi di come si possa cancellare il testo contenuto nelle TextBox presenti nella propria pagina aspx.

Molti di questi esempi partono dal presupposto che la nostra pagina aspx non sia agganciata ad una masterpage. In questo caso, per la particolare gerarchia delle pagine aspx rispetto alla masterpage, bisogna apportare una piccola modifica al codice in questione.

Si deve infatti prima individuare il ContentPlaceHolder all’interno del quale insistono le TextBox di cui si vuole modificare la proprietà Text e successivamente utilizzare una lambda expression per eliminare il testo.

Quando si esegue un debug con F10 in Visual Studio 2008 nel contesto di applicazioni multi-threading, può succede che si perda il controllo dello stesso, emulando il comportamento del tasto F5.

Per risolvere il problema è necessario aggiornare la propria versione di Visual Studio, scaricando l’aggiornamento KB957912.

Il link alternativo si trova su code.msdn

Sono appena tornato dalla conferenza di ASPItalia “Real Code Day”, organizzata a Firenze nella struttura della Scuola Superiore Tecnologie Industriali (SSTI).

Tralascio l’organizzazione, appena sufficiente, considerati i problemi di rete e le continue sospensioni perchè dislocati in più aule collegate in wifi (numerosa partecipazione e, per dovere di cronaca, sentite scuse da parte di tutti anche di un tizio che credo sia il presidente/direttore/responsabile del SSTI.

Mi è piaciuta molto la disponibilità di Stefano Mostarda e Riccardo Golia al dialogo con tutti i partecipanti: una spanna sopra tutti.

Mi son piaciute molto meno le sessioni su WPF e Silverlight 4.0, troppo caciaroni e poco professionali gli speaker, il che, inevitabilmente, ha portato a disattenzione generale (soprattutto nelle aulee collegate in wireless) - una domanda su tutte: ma che ci frega di Silverlight e WPF e dello XAML, noi vogliamo vedere Blend (poi lo XAML ce lo leggiamo online).

Positivo il fatto che questa conferenza, come le altre due che ho seguito negli ultimi due mesi (ed organizzate direttamente da Microsoft), ti fanno tornare la passione di sviluppare applicazioni web di un certo livello e di approcciarsi al mondo dello sviluppo in un modo che non è per niente riscontrabile nella città di Roma (almeno nella mia diretta esperienza personale - spero esistano realtà diverse).

interessanti esperimenti sui tipi CRL

Per chi ancora nel 2009 si dovesse trovare ad utilizzare i dataset ed eventualmente in concomitanza con SQL Server 2008, potrebbe vedere questo errore in Visual Studio 2005, all’atto del tentativo di creazione di un TableAdapter:

“This server version is not supported. Only servers up to Microsoft SQL Server 2005 are supported.”

Per risolvere il problema, basta installare questa patch: VS80sp1-KB954961-X86-INTL

Grazie a Manuel per la segnalazione.

L’obiettivo è la costruzione di un metodo (sia esso public, protected o private)
che ci consenta di estrarre una lista di stringhe.

La signature del nostro metodo sarà:

1

public List<string> getMyString()

Nel caso specifico vogliamo estrarre un set di dati rappresentati
da una e sola colonna di una tabella del nostro database.
Istintivamente, ci verrebbe da scrivere un pezzo di codice del tipo:

1
2
3

var q = from t in context.myentity
select new { Codice = t.mycodice };
List<string> listaCodici = q1.ToList();

Ovviamente è errato, sintatticamente e semanticamente.
Non è corretto supporre che, essendo il campo mycodice, un campo varchar, esso venga poi rimappato in un insieme di stringhe. Il compilatore, quindi, tornerà il seguente errore:

Cannot implicitly convert type
‘System.Collections.Generic.List<anonymoustype #1>’ to ‘System.Collections.Generic.List<string>’

Esistono due diverse strade per ottemperare al nostro obiettivo.
La prima è quella di definire una struct o una classe customizzata che contenga al suo interno la property, stringa, che andremo poi a valorizzare estraendo i dati dal database tramite LINQ.

La seconda è quella di scrivere un pezzo di codice come:

1
2
3
4
5

var q = from t in context.myentity
let codici = new { t.mycodice }
select codici;
List<string> listaCodici = (from c in q
select c.mycodice).ToList();

Ipotizziamo di creare una solution in Visual Studio 2008 che strutturi
la nostra web application su n layer con un Object Model.
Il progetto Object Model conterrà l’Entity Model generato da VS2008.

Il DAL contiene, invece, il cuore dell’accesso ai dati: è nel DAL che
andremo a creare i metodi con le query LINQ per estrarre i dati secondo
le nostre esigenze.

L’obiettivo è quello di estrarre un sottoinsieme dei campi contenuti
nella tabella, dalla quale VS2008 ha creato il modello delle Entity.

Chiamiamo AEntity l’entity definita nel modello.
Intuitivamente vorremmo scrivere un blocco di codice di questo tipo,
dove BaseDataAccess contiene la dichiarazione dell’oggetto context:

1
2
3
4
5
6
7
8
9
10
11
12
13

public class DizionarioDataAccess : BaseDataAccess
{
    public List<objectmodel.AEntity> GetAll()
    {
       var items = from t in context.AEntity
                       select new
                       {
                           Nome = t.TABLE_NAME,
                           Cognome = t.TABLE_COGNOME
                       };
 
       return items.ToList<objectmodel.AEntity>();
    }

Il compilatore tornerà questo errore:

‘System.Linq.IQueryable<anonymoustype #1>’ does not contain a
definition for ‘ToList’ and the best extension method overload
‘System.Linq.Enumerable.ToList<tsource>
(System.Collections.Generic.IEnumerable<tsource>)’
has some invalid arguments

L’errore deriva dal fatto che con la direttiva select new, stiamo andando
a definire un nuovo oggetto che poco ha a che fare con l’Entity definita nel nostro modello.
Per risolvere il problema possiamo seguire due strade: o imponiamo che il
tipo tornato dal nostro metodo sia IQueryable, o creiamo un oggetto customizzato che abbia al suo
interno solo le proprietà che vogliamo valorizzare ed estrarre dal db.

Documento vecchio, che ho avuto occasione di leggere solo oggi.

Un must per tutti gli sviluppatori che vogliono introdursi al Framework .Net 3.5

Noi sviluppatori spesso ci troviamo ad usare, per comodità, gli operatori condizionali (operatori condizionali in c#).

1

a = condizione ? prima_espressione : seconda_espressione;

In passato ho anche affrontato la teoria relativa ai tipi nullable, che ricordo essere dei tipi che accettano il valore null.

Oggi mi è capitato un errore compile-time che, a prima vista, potrebbe sembrare piuttosto banale:

Type of conditional expression cannot be determined because there is no implicit conversion between ‘‘ and ‘System.DateTime’

Spulciando le specifiche del linguaggio c#, ho scoperto un’interessante regola di base che, onestamente, non conoscevo.

Regola:
Ipotizziamo che X ed Y siano i tipi del secondo e terzo operando nell’espressione condizionale.
1. Se X ed Y sono dello stesso tipo, ne consegue che questo tipo è il tipo dell’espressione condizionale.
2. Nel caso in cui X ed Y siano diversi:
2a. se esiste una conversione implicita da X ad Y ma non da Y ad X, allora Y è il tipo dell’espressione condizionale;
2b. se esiste una conversione implicita da Y ad X, ma non da X ad Y, allora X è il tipo dell’espressione condizionale;
3. Nei restanti casi, non è possibile determinare il tipo dell’espressione per cui il compilatore ritorna un errore.

Esempio:

1
2

DateTime? nullableDate;  
nullableDate = (condition) ? null : DateTime.Now;

In questo caso X è null, per cui non c’è nessun tipo ad esso associabile. Nè tantomeno esiste un cast che ci dice che sia un null riferibile ad un qualche tipo specifico.

Non esiste nessuna conversione implicita da X (null) ad Y (DateTime).
Non esiste nessuna conversione implicita da Y (DateTime) ad X (null).

Secondo la regola, quindi, il compilatore deve tornare un errore.

Ovviare a questo problema è semplice: bisogna far capire al compilatore quale sia il tipo dell’espressione condizionale. Per farlo possiamo: fare un cast di entrambe le espressioni a DateTime?, oppure ancora fare un cast di null a DateTime? o, infine, fare un cast da DateTime a DateTime? (in questi ultimi due casi, esisterebbe una conversione implicita)

riferimenti: http://msdn.microsoft.com/en-us/library/aa691313(VS.71).aspx

Recentemente ho scoperto, grazie ad uno sviluppatore conosciuto da poco, l’esistenza dei tipi nullable.
Introdotti a partire dal framework .net 2.0, consentono di assegnare ad una variabile il valore null, oltre il normale range di valori.

Nel caso di una variabile int, oltre il range di valori compreso tra -2147483648 e 2147483647, sarà possibile assegnare anche il valore null.

Ancora: nel caso in cui dovessimo definire una variabile di tipo bool, oltre ai due stati true e false, sarà possibile lavorare su un terzo stato, lo stato null.

Questa tipologia di dato torna utile soprattutto nel caso in cui dovessimo trovarci a testare il valore di una variabile cui associamo un dato estratto da un database. In condizioni normali, dovremmo usare il seguente costrutto:

1
2
3
4

if (valore == null)
    x = -1;
else
    x = valore;

i tipi nullable possiedono due proprietà pubbliche e read-only: hasValue e Value.

* HasValue - restituisce true nel caso la variabile abbia un valore diverso da null
* Value - restituisce il valore assegnato alla variabile nel caso sia diverso da null, oppure un’eccezione InvalidOperationException;

Per cui, potremmo pensare di testare il valore estratto da un database nel seguente modo:

1
2
3
4
5

int? x = campo_db;
if (x.HasValue)
    System.Console.WriteLine(x.Value);
else
    System.Console.WriteLine("Undefined");

(via msdn.microsoft.com)

Dopo qualche mese di utilizzo intensivo, ho deciso di disinstallare resharper 3.1 plugin per visual studio 2005. Difatti, a parte due o tre funzionalità davvero utili la spesa teorica prevista dalla licenza non trova giustificazioni.

Personalmente, ho trovato molto utile la possibilità di analizzare il codice sia nel tentativo di ottimizzarlo, sia nel tentativo di ovviare ad eventuali problemi a run-time, come ad esempio le NullReferenceException. Il plugin in tal senso, risulta molto utile grazie ad accorgimenti grafici semplici ed intuitivi: icone colore rosso per errori gravi, arancioni per possibili warning, verde nel caso in cui il codice sia ok.

Inoltre è utile la creazione di proprietà a partire dalla dichiarazioni di membri, siano essi privati, pubblici o protetti, tramite un comodo wizard all’interno del quale ci viene data la possibilità di definire le diverse caratteristiche della proprietà che stiamo andando a creare.

Il contro più grave, che mi ha poi portato alla disinstallazione del plugin, è il dover caricare in memoria il contenuto dei files aperti nell’IDE: ciò comporta non solo un notevole dispendio di ram (visual studio ne pretendeva regolarmente almeno 600/700 MB) ma anche e soprattutto un tempo di avvio davvero inaccettabile.

Successivamente al passaggio di disinstallazione, scompare la possiiblità di avere l’intellisense. Per riattivarlo, basta andare nel menu Opzioni->Editor di testo->C# e rimettere il check “Elenco membri automatico”.

(via Scott Hanselman’s blog)

Dopo una serie di polemiche sul forum, pare che finalmente siano stati risolti i problemi di Subsonic, relativi ai due metodi GetCount() e GetRecordCount() che potete richiamare sull’oggetto Select.

In realtà, la versione 2.1 final non è fixata. Potete farlo manualmente, modificando i sorgenti, facendo un rebuild della solution e sovrascrivendo il file Subsonic.dll che state utilizzando.

Fix:
Modify SqlQuery/SqlQuery.cs : line 1241
from
count = (int)scalar;
to
count = (int)Utility.ChangeType(scalar, typeof(int));

(via codplex)

L’area di progettazione dei DataSet, fornita da Visual Studio 2005, consente di agganciare una o più tabelle, eventualmente correlate tra loro, grazie ad una serie di semplici click, o drag&drop dal DataSource configurato.

Può capitare che l’IDE visualizzi l’errore “Microsoft.VDesigner ErrorCode:-1″. La motivazione sta nel fatto che si sta cercando di inserire all’interno del DataSet una tabella nella quale risulta assente la chiave primaria, sebbene sia stata definita una chiave UNIQUE.

Per risolvere l’errore, basterà modificare la struttura della tabella da aggiungere, inserendo una chiave primaria.

Premessa:

1. Installare il driver connector MySQL Connector .NET 5.1.4 ta
2. si vuole estrarre da un database mysql un determinato
   numero di righe, sulla base di una stringa di testo passata da un campo TextBox.

Ipotizziamo di dover eseguire una clausola SQL del tipo:

1
2

SELECT oid, nome, cognome 
FROM tabella1 WHERE nome LIKE '%pippo%'

Creiamo il MysqlDataAdapter e la query parametrizzata da eseguire:

1
2

SELECT oid, nome, cognome 
FROM tabella1 WHERE nome LIKE ?nome

Grazie a Visual Studio 2005 è abbastanza banale impostare tutte le proprietà del parametro ?nome, per cui, ci basterà semplicemente richiamare il metodo FillBy nel seguente modo:

1
2

this.myTableAdapter.FillBy(this.myDataSet.tabella1
, '%'+ this.tbox_nomecognome.Text+ '%');

La particolarità sta nel fatto che se andassimo ad inserire le wildcard % direttamente nella clausola sql creata tramite Visual Studio, essa non tornerebbe alcun valore perchè il motore ado.net non riesce a sostituire correttamente il valore del parametro. Per questo motivo, si devono passare le wildcard % come fossero semplici caratteri.

Viva la Microsoft - dove tutto è bello fin quando si sta nel loro seminato, appena se ne esce si perdono 5 ore di lavoro.