[C#] Struttura a campi FixedString

[escocat]

Salve.
Ho creato una struttura che voglio con i campi a lunghezza fissa.
Siccome il VB è un lontano ricordo con i suoi string*25 e <VBFixedString(25)> ho
organizzato delle proprietà non automatiche in questo modo:

public struct R
{
       string _nome;
       public string nome 
       { 
              get 
              {
                   return _nome;
              }
       
              set 
              {
                   _nome = value;
                   if (_nome.Length<26)
                      _nome = _nome.PadRight(25);

                   _nome = _nome.Substring(0,25);
              }
       }

        .......... (altri campi)

}

Volevo sapere se esiste un modo meno impressionante di costruire una struttura a campi FixedString.
Grazie

[rsdpzed]

prima una premessa.
Se lo fai per una questione di prestazioni di memoria allora lascia stare, paradossalmente con quel sistema diminuisci le prestazioni sia di memoria che di calcolo. Il discorso è un po complesso, volendo ne si puo parlare...

Se invece è un discorso di Validazione dell'input allora il tuo metodo va benone.

Tuttavia in .net 4 è stato introdotto un namespace che fa uso degli attributi per validare delle proprietà, questo è molto utile per mantenere il codice pulito visto che puoi continuare a scrivere le proprietà alla maniera di c#3 con la sintassi ridotta e implementare la logica di validazione con gli attributi.
Ti faccio un esempio.

//proprietà definita con la sintassi ridotta...

[Required]
[MaxLenght(25)]
[MinLenght(20)]
public string Nome { get;set; }

La verifica però non è affatto automatica come il metodo setter! è necessario che la classe implementi un interfaccia (IValidatableObject) e scrivere il metodo Validate che deve essere richiamato "a mano". Il metodo verifica una per una le proprietà dell'oggetto (attraverso una classe gia pronta che si chiama Validator) e ritorna una lista di messaggi di errore uno per ogni verifica non andata a buon fine.
PRO: codice piu pulito
CONTRO: Verifica a mano.

Ci sono delle tecnologie .net come asp.net, MVC e Entity Framework che "dietro le quinte" nascondono la necessità di verificare a mano e implementare l'interfaccia IValidatableObject per cui in questi scenari l'uso degli attribbuti è ideale. Cosi come è ideale per tutte quelle occasioni in cui una classe è "colma" di proprietà da validare. Se non è il caso puoi fare come gia stai facendo.

[escocat]

Originariamente inviato da rsdpzed
Se lo fai per una questione di prestazioni di memoria allora lascia stare, paradossalmente con quel sistema diminuisci le prestazioni sia di memoria che di calcolo. Il discorso è un po complesso, volendo ne si puo parlare...

Intanto, ovviamente, ti ringrazio per la risposta, è già tanto di questi tempi.

Si, ne potremmo riparlare, ma non in questa sede perchè la mia necessità di avere fixed string esula dallo scope di questa discussione. Peraltro ho capito che se il C# non possiede qualcosa vuol dire che quel qualcosa in effetti non è lecito richiederla.

Per quanto riguarda gli attributi da te suggeriti non riesco a trovare il namespace di pertinenza (System.Configuration? System.ComponentModel?) ma forse vanno al di là della mia attuale preparazione oltre al fatto che (forse) gestiscono solo i valori di intervallo e non obbligano la stringa ad un valore fisso nella sua lunghezza (ammesso che questo abbia un senso, ne dubito, ci sto riflettendo).

Qualche altra dritta?

[rsdpzed]

System.ComponentModel

è sempre lecito chiedere. Come ti ho detto prima è importante il motivo per cui una cosa va fatta, se è per validare ok, quella è la strada (il setter o l'uso degli attributi). Se invece è un discorso di prestazioni e ottimizzazione cosi come si farebbe normalmente in C, in Turbo pascal, nella progettazione di un DB, allora no, non ha senso perche in c# le stringhe non occupano una lunghezza massima da dimensionare in fase di dichiarazione.

perche:
il runtime alloca lo spazio necessario in base alla inizializzazione e quello spazio rimane immutato.

string s = "ciao";

s occuperà lo spazio necessario a contenere "ciao" ne piu ne meno, non c'è bisogno di dire che s è "lunga 5" come si fa in altri linguaggi. Lo spazio allocato da s è IMMUTABILE e sarà 5 per tutto il suo ciclo vita, questo fatto dell'immutabilità inficia sulle prestazioni e le migliora.

questo è un vantaggio perche non ti devi preoccupare dell'ottimizzazione e delle prestazioni, lo fa il runtime per te. E qui ci potremmo fermare ma per completezza è giusto parlare anche degli svantaggi.

string s = "ciao";
s = s + "mondo";
s = s + "cane";

banale ma si scontra con il concetto di ottimizzazione e immutabilità che ho citato prima. s viene inizializzata per contenere ne piu e ne meno che "ciao", poi però ci attacchiamo "mondo" ed infine "cane" ma come è possibile se s dopo la prima inizializzazione è diventata immutabile? viene creata una nuova stringa di nuovo immutabile per contenere "ciaomondo" e si fa puntare s a questa stringa e cosi via per tutte le volte che la modifichiamo. Questo significa che c'è un lavoro in piu dietro le quinte sia in termini di calcolo che di memoria (invece di occupare 14 occupiamo 5 + 10 + 14 cioè 29: piu del doppio).

Questo vale anche quando modifichi la stringa con i metodi substring() ecc.

esiste un modo per migliorare le prestazioni?
innanzitutto tenere a mente il funzionamento.
usare la classe stringbuilder. quando si deve concatenare una stringa diverse volte lo si fa attraverso la classe stringbuilder in modo da creare la stringa vera e propria solo alla fine.
un altro modo è usare string.Format per inizializzare una stringa invece che l'operatore +.

[escocat]

In queta occasione (solo in questa) non mi interessa l'aspetto delle prestazioni, ma quello della validazione. Nel vecchio VB5 se creavo una stringa

Dim s As String*10
s = "xxxxxxxxxx" (10 ics)

e poi cercavo di "forzarla" per esempio con

Mid(s, 5, 20) = "12345678901234567890"

il risultato era

s = "xxxx123456"

giustamente. Questa stringa non è "middabile" oltre il suo fixedlength. Cerco la stessa cosa in C#, che peraltro non ha la funzione del Mid (almeno non mi risulta). Devo verificare se le proprietà che ho scritto nel codice possano impedire un Mid forzato (potrebbero essere solo a protezione di una validazione ma non di un Mid forzato). Voi direte "Ma allora chiedi prima di verificare?". Si, anche se quelle proprietà riescono a impedire un Mid forzatoi a me sembra un codice troppo macchinoso e cerco lo stesso servizio di String*10 con meno codice.

P.S. Si, ho verificato che quelle proprietà rendono la stringa non middabile:

R r1 = new R(); 

r1.nome = "123456789012345678901234567890";

MessageBox.Show(r1.nome);   ------> dà "1234567890123456789012345" (GIUSTO)

r1.nome = r1.nome.Insert(20, "xxxxxxxxxxxxxxxxxx");

MessageBox.Show(r1.nome); --------> dà "12345678901234567890xxxxx" (GIUSTO)