Latest Posts
Alcuni clienti mi chiedevano se fosse possibile rendere editabile un work item solo dalla persona a cui questo è assegnato in un dato momento in modo da poter creare un sistema ti gestione ticket standard dove un utente di abse può vedere ed editare solo i propri ticket. Purtroppo questo non è fattibile.
Una soluzione alternativa molto semplice è comunque possibile tramite l’utilizzo della security su TFS. Si deve fare in modo che l’utente posssa visualizzare solo i work item assegnati ad esso tramite un Work Item Query dedicata. Bisogna quindi lavorare sulla security in modo da non consentire agli utenti standard la creazione o la modifica delle query esistenti, in modo da consentire solo ed unicamente l’utilizzo della query creata sopra.
Sfrutto un po’ il mio blog per cercare di risolvere un dilemma nato in questi giorni.
Sono in procinto di iniziare lo sviluppo della nuova versione di un applicativo già esistente. L’applicativo suddetto è realizzato in ASP.NET, gira in intranet, non è strettamente necessario che sia multibrowser (anche se non sarebbe male) e per lo più consente la visualizzazione e l’inserimento di dati, quindi classiche griglie, form più o meno complesse, etc, etc.
Con queste premesse ci siamo chiesti se convenga continuare ad utilizzare ASP.NET o non sia meglio passare a Silverlight.
Uno dei requisiti della nuova versione è quella di avere un’interfaccia grafica più user-friendly.
Voi cosa fareste al posto mio?
Ogni tanto, nello sviluppo software, emerge qualche meme come ad esempio: tutte le dipendenze devono essere
disaccoppiate tramite un interface, tutte gli oggetti devono essere creati tramite factory, l'accesso ad un database
deve avvenire tramite un ORM, il TDD genera un buon design ecc.
Cosa hanno in comune tutte le frasi precedenti? Semplice: creano scorciatoie per evitare di pensare.
Sarebbe bello se potessimo scrivere codice seguendo alla lettera un manuale, ma sarebbe anche terribilmente noioso
e probabilmente verremmo sostituiti da qualche tipo di bot.
Prendiamo la prima affermazione: tutte le dipendenze devono essere disaccoppiate tramite un interface
e cerchiamo di capire da dove nasce questa esigenza. Il vantaggio di avere le dipendenze solo tramite interfacce dovrebbe essere quello
di rendere più testabile le nostre classi. Ma è l'unico modo? Ed è il più semplice?
Proviamo a fare un esempio. Supponiamo di voler testare il metodo SayHello:
var display = new Display();
var greeting = new Greeting(display);
greeting.SayHello();
L'implementazione di Greeting è la seguente:
public class Greeting
{
private readonly Display _display;
public Greeting(Display display)
{
_display = display;
}
public void SayHello()
{
_display.Show("Hello!");
}
}
Mentre l'implementazione di display è la seguente:
public class Display
{
public void Show(string text)
{
Console.WriteLine(text);
}
}
Sembra proprio il tipico esempio da manuale in cui si estrae l'interfaccia IDisplay e tramite la libreria di mocking preferita testo le interazioni
di Greeting con Display. Esiste un'alternativa?
La classe Console eredita da TextWriter, anche la classe StringWriter eredita da TextWriter. Proviamo quindi a passare la
Console in costruzione a Display:
public class Display
{
private readonly TextWriter _textWriter;
public Display(TextWriter textWriter)
{
_textWriter = textWriter;
}
public void Show(string text)
{
_textWriter.WriteLine(text);
}
}
Ora modfichiamo il main:
var display = new Display(Console.Out);
var greeting = new Greeting(display);
greeting.SayHello();
A questo punto possiamo scrivere il test:
var stringWriter = new StringWriter();
var greeting = new Greeting(new Display(stringWriter));
greeting.SayHello();
Assert.That(stringWriter.ToString(), Is.EqualTo("Hello!"));
In questo modo abbiamo fatto un test più solido rispetto a testare l'interazione con un interfaccia ed il codice è più semplice.
Create your application to work without either a UI or a database so you can run automated regression-tests against the application, work when the database becomes unavailable, and link applications together without any user involvement.
Known also as: Hexagonal Architecture
Read the full description here: http://alistair.cockburn.us/Hexagonal+architecture
I know that my Italian friends Matteo Vaccari e Antonio Carpentieri have presented sessions about this topic at the London XP Days and in other agile events, so they can be trustworthy source when you want to ask questions about this topic.
Problema:
Dato un insieme I di n intervalli [a, b] con a e b interi determinare il sottoinsieme piu’ grande di intervalli mutuamente non sovrapposti che possono essere selezionati da I.
Input:
Due vettori di n interi che rappresentano l’insieme I.
a = { a0, a1, … }
b = { b0, b1, … }
Ogni intervallo e’ identificato da un numero intero k.
L’intervallo generico k e’ rappresentato dagli estremi a[k] e b[k].
Output:
Una lista di interi ordinata (List<int>) che contiene gli identificatori degli intervalli che fanno parte del sottoinsieme di interesse.
Esempio:
Input:
a = { 0, 7, 15, 2, 8, 15, 18, 3, 10, 12, 15, 1, 4, 8, 20 };
b = { 4, 12, 18, 6, 14, 17, 20, 9, 11, 14, 19, 5, 7, 20, 22 };
Output:
{ 0, 5, 6, 8, 9, 12, 14 } oppure
{ 0, 2, 6, 8, 9, 12, 14 }
Di seguito i diagrammi che rappresentano i due risultati validi (evidenziati in giallo):
Il mio ragionamento:
Per ciascun intervallo determino gli intervalli che si sovrappongono. Ordino quindi gli intervalli in base al numero di sovrapposizioni. Partendo dagli intervalli con il minor numero di sovrapposizioni inizio ad aggiungerli al risultato, scartando a mano a mano gli intervalli sovrapposti.
La complessita’ di questa soluzione e’ O(N^2).
Non sono in grado di provare se questa soluzione e’ corretta per qualsiasi istanza del problema.
La mia soluzione:
class Interval
{
public int ID { get; set; }
public List<int> Overlaps { get; set; }
public bool IsCandidate { get; set; }
public Interval(int interval)
{
ID = interval;
Overlaps = new List<int>();
IsCandidate = true;
}
}
static List<int> GetBiggestNonOverlappedIntervalSubset(int[] a, int[] b)
{
if (a == null) throw new ArgumentNullException("a");
if (b == null) throw new ArgumentNullException("b");
if (a.Length != b.Length) throw new ArgumentException("a and b must have the same length");
int n = a.Length;
List<int> results = new List<int>();
Interval[] intervals = new Interval[n];
for (int i = 0; i < n; ++i)
intervals[i] = new Interval(i);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (a[i] < b[j] && a[j] < b[i])
{
intervals[i].Overlaps.Add(j);
intervals[j].Overlaps.Add(i);
}
Array.Sort<Interval>(intervals, (info1, info2) => info1.Overlaps.Count - info2.Overlaps.Count);
for (int i = 0; i < n; ++i)
if (intervals[i].IsCandidate)
{
int newInterval = intervals[i].ID;
results.Add(newInterval);
for (int j = i + 1; j < n; ++j)
if (intervals[j].Overlaps.Contains(newInterval))
intervals[j].IsCandidate = false;
}
results.Sort();
return results;
}
I miei test:
Un problema piu’ complesso come questo richiede la presenza di qualche test automatico.
[TestMethod()]
public void GetBiggestNonOverlappedIntervalSubsetTest_DisjointedIntervals()
{
int[] a = new int[] { 0, 6, 10 };
int[] b = new int[] { 4, 8, 12 };
var expected = new List<int> { 0, 1, 2 };
List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
Assert.IsTrue(actual.Count == 3);
CollectionAssert.AreEquivalent(expected, actual);
}
[TestMethod()]
public void GetBiggestNonOverlappedIntervalSubsetTest1()
{
int[] a = new int[] { 0, 7, 15, 2, 8, 15, 18, 3, 10, 12, 15, 1, 4, 8, 20 };
int[] b = new int[] { 4, 12, 18, 6, 14, 17, 20, 9, 11, 14, 19, 5, 7, 20, 22 };
var expected1 = new List<int> { 0, 5, 6, 8, 9, 12, 14 };
var expected2 = new List<int> { 0, 2, 6, 8, 9, 12, 14 };
List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
Assert.IsTrue(actual.Count == 7);
Assert.IsTrue(ListEquals(actual, expected1) || ListEquals(actual, expected2));
}
[TestMethod()]
public void GetBiggestNonOverlappedIntervalSubsetTest2()
{
int[] a = new int[] { 0, 1, 2, 3, 4 };
int[] b = new int[] { 2, 3, 4, 5, 6 };
var expected = new List<int> { 0, 2, 4 };
List<int> actual = Program_Accessor.GetBiggestNonOverlappedIntervalSubset(a, b);
Assert.IsTrue(actual.Count == 3);
CollectionAssert.AreEquivalent(expected, actual);
}
private bool ListEquals(List<int> a, List<int> b)
{
if (a.Count != b.Count) return false;
int n = a.Count;
for (int i = 0; i < n; ++i)
if (a[i] != b[i])
return false;
return true;
}
Voi come lo avreste implementato? Idee?
Pensate che la mia soluzione sia corretta?
Se no, potete fornire un contro esempio che porta ad un risultato scorretto?
Problema:
Abbiamo una matrice quadrata (N x N) di interi che rappresenta una immagine. Scrivere un algoritmo che ruota l’immagine di 90 gradi in senso orario.
Input:
Una matrice quadrata (N x N) di interi.
Output:
Una matrice quadrata (N x N) di interi.
Esempio:
Input:
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48
49 50 51 52 53 54 55 56
57 58 59 60 61 62 63 64
Output:
57 49 41 33 25 17 9 1
58 50 42 34 26 18 10 2
59 51 43 35 27 19 11 3
60 52 44 36 28 20 12 4
61 53 45 37 29 21 13 5
62 54 46 38 30 22 14 6
63 55 47 39 31 23 15 7
64 56 48 40 32 24 16 8
Il mio ragionamento:
Grazie al fatto che la matrice e’ quadrata non e’ necessario costruire una nuova matrice e poi copiare gli elementi in modo opportuno. E’ possibile effettuare la rotazione sul posto. L’algoritmo e’ scomposto in un certo numero di microrotazioni ciasuna delle quali coinvolge 4 elementi. L’insieme degli elementi di partenza di ciascuna microrotazione deve essere scelto accuratamente per assicurare che tutte le microrotazioni coinvolgano elementi diversi dell’immagine e quindi che ogni elemento venga spostato una volta sola.
Questa immagine mostra evidenziati in giallo gli elementi di partenza delle microrotazioni nel caso di una immagine 8 per 8. Inoltre viene mostrata la microrotazione che coinvolge il primo elemento in altro a sinistra.
La mia soluzione:
static void Rotate90Clockwise(int[][] image)
{
if (image == null) throw new ArgumentNullException("image");
int n = image.Length;
for (int i = 0; i < n; ++i)
if (image[i].Length != n)
throw new ArgumentException("image must be a square");
int m = n / 2;
for (int i = 0; i < m; ++i)
{
int maxi = n - i - 1;
for (int j = i; j < maxi; ++j)
{
int maxj = n - j - 1;
int temp = image[i][j];
image[i][j] = image[maxj][i];
image[maxj][i] = image[maxi][maxj];
image[maxi][maxj] = image[j][maxi];
image[j][maxi] = temp;
}
}
Codice di contorno per verificare l’algoritmo:
static void PrintImage(int[][] image)
{
int n = image.Length;
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
Console.Write("{0,3} ", image[i][j]);
Console.WriteLine();
}
}
static int[][] CreateImage(int n)
{
int[][] image = new int[n][];
for (int i = 0; i < n; ++i)
image[i] = new int[n];
int color = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
image[i][j] = color++;
return image;
}
Una versione parallela
Come suggerito da Leonardo un algoritmo di questo tipo puo’ essere facilmente reso parallelo in quanto ciscuna microrotazione e’ indipendente dalle altre. Non ho ancora studiato le Parallel Extension di .NET tuttavia ho voluto provare a sostituire un for con un Parallel.For e fare qualche misurazione.
static void Rotate90Clockwise_Parallel(int[][] image)
{
if (image == null) throw new ArgumentNullException("image");
int n = image.Length;
for (int i = 0; i < n; ++i)
if (image[i].Length != n)
throw new ArgumentException("image must be a square");
int m = n / 2;
Parallel.For(0, m, i =>
{
int maxi = n - i - 1;
for (int j = i; j < maxi; ++j)
{
int maxj = n - j - 1;
int temp = image[i][j];
image[i][j] = image[maxj][i];
image[maxj][i] = image[maxi][maxj];
image[maxi][maxj] = image[j][maxi];
image[j][maxi] = temp;
}
});
}
Misurazioni sul mio Dual Core
Per N piccolo la versione non parallela e’ quella migliore. Il valore di N per cui la versione parallela diventa piu’ efficiente e’ intorno a 250.
N Non parallel (sec) Parallel (sec)
50 0,0011197 0,0032796
100 4,51E-05 0,0001689
150 9,8E-05 0,0001268
200 0,0001755 0,0002104
250 0,0002587 0,0002371
300 0,0004086 0,0003414
350 0,0005709 0,0004235
400 0,0007465 0,0005226
450 0,0009816 0,0006658
500 0,0015623 0,0009149
550 0,0016398 0,0011212
600 0,0019129 0,0011746
650 0,0025198 0,0026563
700 0,0032237 0,0022549
750 0,0036323 0,0020962
800 0,0045339 0,0046006
850 0,0050175 0,0031169
900 0,0056665 0,0032344
950 0,0064017 0,0037355
1000 0,0076806 0,0042115
Per N piu’ grandi si puo’ notare come la versione parallela porti ad un miglioramento di circa il 25%.
N Non parallel (sec) Parallel (sec)
1000 0,0077073 0,0073474
2000 0,0332968 0,020059
3000 0,0805194 0,0478967
4000 0,1537109 0,0925035
5000 0,2477418 0,1521573
6000 0,3798181 0,2527799
7000 0,5527379 0,3792611
8000 0,9368898 0,7253927
9000 1,1020627 0,9026483
10000 1,5610223 1,2783356
Problema:
Date due parole (stringhe) dire se sono anagrammi.
Input:
Due stringhe che rappresentano due parole (spazi esclusi)
Output:
Un booleano
Esempio:
Input: “nave” e “vena”
Output: true
Input: “nave” e “neve”
Output: false
Il mio ragionamento:
Se le due parole hanno un numero di caratteri differenti non possono essere anagrammi.
Calcolo il numero di occorrenze di ciascun carattere nella prima parola.
Per ogni carattere della seconda parola verifico se ce n’e’ uno corrispondente nella prima decrementando il contatore corrispondente. Se uno dei contatori e’ pari a zero prima del decremento significa che non c’e’ un numero sufficiente di caratteri e quindi ritorno false.
Nota: contare se un qualche contatore e’ rimasto maggiore di zero dopo l’ultimo foreach non e’ necessario perche’ sappiamo che le due parole hanno la stessa lunghezza. Se il numero di occorrenze di una certa lettera nella prima parola e’ maggiore rispetto al numero di occorrenze nella seconda parola, allora esistera’ sempre la situazione opposta.
La mia soluzione:
static bool IsAnagram(string s1, string s2)
{
if (s1 == null) throw new ArgumentNullException("s1");
if (s2 == null) throw new ArgumentNullException("s2");
if (s1.Length != s2.Length)
return false;
uint[] counters = new uint[char.MaxValue + 1];
foreach(char c in s1)
++counters[c];
foreach(char c in s2)
if( counters[c]-- == 0) return false;
return true;
}
Parto dal post The Future of Silverlight del Silverlight Team Blog per suggerire una opportunitá di miglioramento.
Silverlight é stato un prodotto che ha esplorato delle possibili aree di innovazione e che ha mantenuto le opzioni aperte in attesa di scoprire come si sarebbe sviluppato il futuro del HTML 5. Una strategia di innovazione che invidiamo a Microsoft e vorremmo fosse adottata anche dalle aziende per cui lavoriamo. Nessuna delusione quindi per un naturale cambio dei piani, anzi un hurrá per Microsoft che ha trovato la strada migliore che porta verso il futuro prossimo.
Il suggerimento va invece a quei colleghi e amici blogger in UGI e dintorni che hanno descritto Silverlight come una tecnologia strategica per il Web con un futuro certo, destinata a restare e su cui investire molto.
Prodotti e innovazioni tecnologiche destinate a restare e su cui investire senza dubbi esistono e ce ne sono state, ad esempio Windows2000 (l'inizio di una nuova stabilitá e soliditá nei prodotti server e nei nuoi servizi di classe enterprise disponibili), il .NET Framework 1.0 (l'ingresso nella programmazione moderna e la via alla programmazione poliglotta), Vista (per un nuovo risperttabile standard di sicurezza nei prodotti consumer), Windows7 (per una nuova e rispettabile attenzione alle prestazioni).
Silverlight chiaramente e notoriamente rientrava in una categoria molto diversa, quella appunto di un prodotto esplorativo.
L'opportunitá di miglioramento che vedo per gli amici Blogger di tecnologia e per me quindi é quella di essere chiari
- nel tipo di tecnologia che si sta recensendo (tecnologia esplorativa/sperimentale, tecnologia strategica destinata a restare, ...),
- nel suggerire investimenti di tempo (hold, assess, trial, adopt) in coerenza a questo dato
e nello scoprire questi elementi basandosi sulla propria competenza, esperienza, professionaliá, indipendenza e autonomia di giudizio. Mi viene in mente il http://www.thoughtworks.com/radar/.
Scegliere e affermare di una tecnologia in un certo momento hold, assess, trial o adopt non é sempre cosi facile e sicuro. Questo peró non frena nessuno dal provare una nuova tecnologia, descrivere sul proprio blog gli esperimenti tecnici fatti, le scoperte e dare suggerimenti tecnici. Semplicemente ci si puo astenere dallo "schierarsi" e fare il push di una tecnologia tessendone le lodi e spronando tutti a investirci e adottarla.
Insomma continuando a divertirsi, mantenendo la propria credibilitá professionale senza rischiare di essere confusi per un PR commerciale delle tecnologie Microsoft parziale e interessato.
Problema:
Rimuovere tutti i caratteri duplicati da una stringa. Gli spazi devono essere preservati.
Vincoli:
Se si utilizza C++ modificare direttamente il parametro di input senza utilizzare buffer aggiuntivi.
Se si utilizza C# ritornare una nuova stringa. In quanto le stringhe sono immutabili, e’ consentito l’utilizzo del metodo ToCharArray() per attenere un buffer su cui lavorare.
Input:
Una stringa
Output:
Una stringa
Esempio:
Input: “Microsoft .Net Framework”
Output: “Microsft .Ne Famwk”
Il mio ragionamento:
Itero il buffer della stringa e costruisco all’inizio di esso la stringa risultato. Uno speciale indice mi indichera’ la posizione dell’ultimo elemento nella stringa risultato. Un nuovo carattere sara’ aggiunto solo dopo la verifica che non sia un duplicato, mentre uno spazio sara’ sempre aggiunto.
La complessita’ dell’algoritmo e’ O(N^2) dove N e’ il numero di elementi distinti presenti nella stringa.
Una soluzione piu’ efficiente consiste nell’utilizzare un vettore di booleani di appoggio per ricordarsi quali caratteri sono gia’ stati visitati. Questo evita un ciclo innestato rendendo la soluzione di complessita’ lineare.
La mia soluzione in C++:
void RemoveDuplicates(char* s)
{
if (s == NULL) throw exception("s cannot be null");
char c;
int i = 0;
int end = 0;
while(c = s[i])
{
bool duplicate = false;
if (!isspace(c))
{
for(int j = 0; j < i; ++j)
if (s[j] == c)
{
duplicate = true;
break;
}
}
if (!duplicate) s[end++] = c;
++i;
}
s[end] = 0;
}
La mia soluzione in C#:
public static class StringExtension
{
public static string RemoveDuplicates(this string s)
{
if (s == null) throw new ArgumentNullException("s");
if (s.Length < 2) return s;
char[] vc = s.ToCharArray();
int len = s.Length;
int end = 0;
for (int i = 0; i < len; ++i)
{
char c = vc[i];
bool duplicate = false;
if (!char.IsWhiteSpace(c))
for (int j = 0; j < end; j++)
if (c == vc[j])
{
duplicate = true;
break;
}
if (!duplicate)
vc[end++] = c;
}
return new string(vc, 0, end);
}
}
Soluzione in C# piu’ efficiente
public static string RemoveDuplicates(this string s)
{
if (s == null) throw new ArgumentNullException("s");
if (s.Length < 2) return s;
char[] vc = new char[s.Length];
bool[] visited = new bool[char.MaxValue + 1];
int end = 0;
foreach (char c in s)
{
if (!visited[c] || char.IsWhiteSpace(c))
{
vc[end++] = c;
visited[c] = true;
}
}
return new string(vc, 0, end);
}
Il modello di UI di Windows Phone 7, per le applicazioni realizzate con Siliverlight, prevede una specifica area, chiamata Application Bar nella quale possono essere piazzati fino a 4 pulsanti, con la relativa icona. Nell’SDK ci sono una trentina di queste icone, ma se volte fare le vostre icone personalizzate dovete procedere seguendo queste regole:
- L’icona deve essere un PNG trasparente
- L’icona deve avere una dimensione di 48x48 pixel
- L’icona NON deve avere il cerchio, a realizzare il cerchio e le animazioni ci pensa il sistema operativo;
- La parte visibile dell’icona deve essere bianca. Il sistema operativo provvederà a cambiare il bianco in nero in caso l’utente scelga l’impostazione con sfondo bianco, e in grigio per i pulsanti disabilitati.
- L’icona deve avere una grafica pulita, con i “fili”(strokes) di almeno 3 pixel.
Io mi sono fatto un modello in Expression Design 4 con il quale sto realizzando le icone delle mie applicazioni. Potete scaricarlo qua.
Nel template c’è il cerchio bianco che non deve essere esportato, ma serve come riferimento e come eventuale tracciato di ritaglio. Inoltre è presente un box di 47 x 47 pixel con Fill e Stroke trasparenti che serve a creare la dimensione corretta dell’icona.
Se avete richieste o chiarimenti potete scrivere nel forum italiano su Expression.
In questi giorni prima di rimettermi in moto in vista della tesi di laurea, ho ultimato e perfezionato un progetto personale che consiste nel riconoscere i gesti della mano utilizzando EmguCV. Le tecniche con cui è possibile estrarre e riconoscere una mano sono molteplici. Nell’approccio scelto sono andato a lavorare su alcuni spazi di colore quale ad esempio YCrCb oppure Hsv definendo una particolare regione dello spazio che contiene la distribuzione di colore della pelle. Eseguito questo filtraggio si ottiene una maschera binaria della nostra mano, che successivamente viene processata al fine di rimuovere il rumore residuo. Dopo aver ottenuto questa maschera binaria è possibile estrarne il contorno e calcolare la Convex Hull. Da questa attraverso un’analisi della convessità con la quale si formano le varie regioni comprese tra il contorno della mano e la convex hull è possibile ottenere delle misure significative che permettono di calcolare come fatto il numero delle dita. Il riconoscimento dei gesti può essere utilizzato in molteplici scenari applicativi tipici dell’ interazione uomo macchina.
E’ possibile scaricare l’intera solution VS10 sul mio account dropbox:
1) Full Demo Solution (Code + video 43Mb)
http://db.tt/MukGcwB
2) Full Demo Code (5Mb)
http://db.tt/GkT6J9k
Un doveroso ringraziamento ad Andol per avermi già citato in uno dei suo post e per i vari feedback ricevuti.
Ad maiora
Ce l’ho fatta ! Stamattina ho passato l’esame 70-512 e sono MCTS su TFS 2010 !!!
Mi capita spesso orami di aggiungere alle mie textbox la funzionalità di autocompletamento che migliora notevalmente la user experience delle mie applicazioni. Aggiungere questa funzionalità con jQuery UI è davvero semplice, basta aggiungere lo script:
1: <script type="text/javascript">
2: $(function () {
3: var valori = ["Primo", "Secondo", "Terzo", "Quarto", "Quinto"];
4: $("#id_mia_textbox").autocomplete({
5: source: valori
6: });
7: });
8: </script>
Anche perchè con Asp.Net 4 è stata introdotta la possibilità di rendere statica la generazione dell’id dell’elemento input a partire da quello assegnato alla textbox da cui verrà generato, l’ormai famoso ClientIdMode:
1: <form id="form1" runat="server">
2: <div>
3: <asp:TextBox runat="server" ID="id_mia_textbox" ClientIDMode="Static" />
4: </div>
5: </form>
Aggiungiamo un po’ di riferimenti (tutto scaricabili dal sito di jQuery UI) ….
1: <link href="Styles/jquery-ui-1.8.4.custom.css" rel="stylesheet" type="text/css" />
2: <script src="Scripts/jquery-1.4.2.min.js" type="text/javascript"></script>
3: <script src="Scripts/jquery-ui-1.8.4.custom.min.js" type="text/javascript"></script>
Ed ecco il risultato
Nel prossimo post vedremo come caricare quei valori da una fonte dati.
-- Michele
Problema:
Data una stringa, calcolare e ritornare una nuova stringa con gli stessi caratteri ma in ordine inverso.
Esempio: ABCDE
Risultato: EDCBA
Input:
Una stringa.
Output:
La stringa di input con i caratteri in ordine inverso.
Il mio ragionamento:
Costruisco un vettore di caratteri lungo quanto la stringa e lo riempio con un semplice ciclo for.
La mia soluzione:
public static string Reverse(string s)
{
if (s == null) throw new ArgumentNullException("s");
if (s.Length < 2) return s;
char[] vc = new char[s.Length];
int n = s.Length - 1;
for (int i = 0; i <= n; ++i)
vc[i] = s[n - i];
return new String(vc);
}
Problema 1:
Determinare se in una stringa tutti i caratteri sono diversi tra loro.
Problema 2:
Risolvere il problema 1 senza usare strutture dati aggiuntive.
Input:
Una stringa
Output:
Un booleano
Il mio ragionamento:
Sfrutto un vettore di booleani con un numero di elementi pari a tutti i possibili caratteri. Itero la stringa e per ogni carattere setto il corrispondente elemento del vettore a true. Se prima di settare lo trovo gia’ a true significa che quello e’ un carattere ripetuto e restituisco subito false. Se si termina l’iterazione allora ritorno true.
Senza strutture dati non si puo’ fare altro che controllare ogni coppia di caratteri.
Le mie soluzioni:
public static bool IsStringWithUniqueCharacters1(string s)
{
if (s == null) throw new ArgumentNullException("s");
if (s.Length < 2) return true;
bool[] flags = new bool[Char.MaxValue + 1];
foreach (char c in s)
if (flags[(int)c]) return false;
else flags[(int)c] = true;
return true;
}
public static bool IsStringWithUniqueCharacters2(string s)
{
if (s == null) throw new ArgumentNullException("s");
if (s.Length < 2) return true;
int n = s.Length;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (s[i] == s[j]) return false;
return true;
}
Ricapitolando:
- Lo stream era effettivamente h264, ma VLC (1.1.14 per Windows) non be ha proprio voluto sapere di visualizzarlo; in compenso sull’iPhone si vedeva benissimo quindi ho seguito così l’evento
- Ho fatto benissimo ad attendere la presentazione della nuova versione di Apple TV, così ora sarò ancora più sicuro nell’acquistare il WD Live HD <g> Peccato, se a quel prezzo e con quel fattore di forma avesse supportato almeno DLNA ci avrei potuto fare un pensierino. La mancanza del supporto FullHD, dato il prodotto, IMHO non è una penalizzazione eccessiva: in fondo, Apple TV è un “aggeggio” per fare streaming via Internet, e temo che nemmeno negli USA la banda sia sufficiente per fare streaming real time di contenuti 1080p.
- iTunes 10 visualizza a sx la thumb della copertina dell’album, e a dx l’elenco delle canzoni. Ottima idea: se non fosse che Windows Media Player e lo Zune player lo fanno da anni, oltre che “ottima” sarebbe stata anche “originale”
- Anche il “social network della musica” è una idea interessante; *2 anni addietro*, quando acquistai lo Zune, fu uno dei primi servizi che attivai: guardavo la mia pagina del profilo beandomi che i miei “top ascolti” fossero: Afterhours, Depeche Mode, Joy Division, Cure, … E nel sapere che i 4 gatti che lo bazzicavano lo avrebbero saputo. Al pari del punto precedente, sono contento che anche in questo caso le fotocopiatrici di Cupertino abbiano funzionato bene <g>
P.S.: Tra parentesi, l’idea del social network era talmente interessante che Microsoft l’ha ormai praticamente ridotta ai minimi termini, mentre Apple la cavalcherà e tutti crederanno che sia una sua idea. Un po’ come inventare XMLHTTP (e quindi AJAX) per poter implementare OWA e poi dimenticarselo lì per *anni*, e poi tutti a credere che ad innovare sia stata Google quando pubblicò Google Maps. Cose che succedono, se il marketing te lo fa Topo Gigio <g>
La coding-competition comincerá il 20 settembre con la pubblicazione del codice del framework che contiene l'interfaccia che ogni algoritmo di Battleship iscritto alla competizione dovrá implementare.
La competizione sará in 2 tornate:
1^ tornata, consegna del codice entro il 10 Ottobre
2^ tornata, consegna del codice entro il 31 Ottobre
Regole del gioco Battleship:
- Si gioca su una griglia 10x10.
- Ogni giocatore dispone sulla griglia 5 navi di lunghezza: 2, 3, 3, 4 e 5.
- La navi possono essere adiacenti ma non sovrapporsi.
- Ogni giocatore a turno spara un singolo colpo sulla griglia del suo avversario.
- L'avversario notifica se il colpo é andato a vuoto, se ha colpito una nave o se ha colpito e affondato una nave
In questo ultimo caso dirá anche quale nave ha affondato e dove era posizionata.
- Il gioco si conclude quando tutte le navi di un giocatore vengono affondate, il giocatore avversario é dichiarato vincitore.
Regole della competizione:
- Lo spirito della competizione é quello di produrre il miglior algoritmo (di attacco e di difesa) per il gioco Battleship.
- Ogni azione che va contro lo spirito della competizione verrá valutata e potrá portare alla eliminazione.
- Imparare e implementare idee altrui é ok, copiare codice altrui va contro lo spirito della competizione.
- Giocare slealmente e interferire sul gioco del avversario va contro lo spirito della competizione.
- Un tempo compessivo di 4 secondi é a disposizione ad ogni giocatore per ogni singola partita.
- L'uso di multi-threading non é concesso.
- Lo sfondamento dei 4 secondi determinerá la sconfitta nella partita corrente.
- Qualsiasi eccezzione sollevata e non gestita determinerá la sconfitta nella partita corrente.
- Il codice insieme alla descrizione delle idee e strategie implementate dovrá essere inviato entro e non oltre le date indicate contattandomi attraverso i contacts di questo blog e inviandomi poi per e-mail il codice o il link da dove scaricarlo.
- La dimensione massima per il codice é di 1MB.
- Il solo requisito tecnico é l'uso del framework .Net 2.0 / 3.5.
- L'algoritmo (di attacco e di difesa) proposto dovrá implementare l'interfaccia IBattleshipOpponent definita nel codice fornito.
Punteggio:
- Ogni partecipante si scontrerá con ogni altro partecipante al meglio di 501 partite su 1000
- La prima metá dei partecipanti con i risultati migliori parteciperá alla prima o alla seconda tornata parteciperá a un torneo a eliminazione diretta per determinare il vincitore
- I risultati insieme all codice e le idee e strategie implementate saranno postati su questo blog.
Con Windows 7 avevo il problema frequente di dover fare reboot o shutdown a computer via Remote Desktop. Purtroppo nel menu di start si puo’ fare solo LogOff o Lock. Mi ero organizzato usando dei comandi tipo:
'shutdown -f -s -t 1' per lo shutdown
'shutdown -f -r -t 1' per il restart
Poi su Channel 10 e’ uscito un articolo su JumpControl che aggiunge un bottone nella taskbar che permette di fare Shutdown e Restart. Una meraviglia!
Ora che abbiamo passato le votazioni, e abbiamo inviato foto e biografie, possiamo dire ufficialmente che DotDotNet parteciperà al NHibernate Day.
Io e i miei compari Igor e Luca terremo una sessione riguardante la configurazione “smart” di un’applicazione, utilizzando gli Event Listeners di NHibernate per aggiungere funzionalità senza stravolgere la struttura iniziale.
Partecipare ad una conferenza dove sono presenti tanti speaker di rilievo non è da tutti i giorni, ma faremo del nostro meglio.
Per chi si è iscritto, ci vediamo a Bologna il 9 ottobre 2010.
Technorati Tags:
DotDotNet
Una delle cose che rendono altissima la produttività di Asp.Net Web Forms è sicuramente la possibilità di usare i validatori, che in maniera rapida e indolore permettono di evitare il post di un form quando ci sono campi che non rispettano le nostre regole di validazione. Semplicemente trascinando un validatore sul form e impostando il controllo da validare vengono generati per noi i controlli javascript necessari alle nostre esigenze più comuni.
Chi mi conosce sa che odio usare il designer e preferisco sempre scrivere le pagine aspx in modalità source, quindi una prima cosa interessante mostrata anche dal nostro buon Alessandro durante un live meeting di DotNetCampania è la possibilità di farci aiutare a inserire il validatore. Digitando ad esempio la stringa requiredfieldvalidator subito dopo il controllo che vogliamo validare e a cui abbiamo dato un identificativo…
1: <form id="form1" runat="server">
2: <div>
3: <asp:TextBox runat="server" ID="MyTextBox" />
4: requiredfieldvalidator
5: </div>
6: </form>
… premendo il tasto TAB otteniamo, per la mia e spero la vostra gioia, il codice dell’elemento <asp:RequiredFieldValidator> con l’attributo ControlToValidate già impostato e il cursone posizionato sul testo selezionato del messaggio di errore da mostrare:
1: <form id="form1" runat="server">
2: <div>
3: <asp:TextBox runat="server" ID="MyTextBox" />
4: <asp:RequiredFieldValidator ErrorMessage="errormessage" ControlToValidate="MyTextBox"
5: runat="server" />
6: </div>
7: </form>
Completando il nostro form in modo che semplicemente modifichi il testo di una label con quello inserito nella textbox alla pressione di un pulsante, possiamo andare a implementare questa difficilissima logica business nell’handler del pulsante:
1: <form id="form1" runat="server">
2: <div>
3: <asp:TextBox runat="server" ID="MyTextBox" /><asp:RequiredFieldValidator ErrorMessage="Obbligatorio!"
4: ControlToValidate="MyTextBox" runat="server" />
5: <br />
6: <asp:Button ID="MyButton" Text="Invia" runat="server"
7: onclick="MyButton_Click" /><asp:Label
8: ID="MyLabel" Text="text" runat="server" />
9: </div>
10: </form>
1: protected void MyButton_Click(object sender, EventArgs e)
2: {
3: this.MyLabel.Text = this.MyTextBox.Text;
4: }
Tutto bene se non fosse per il fatto che purtroppo esistono scenari in cui javascript è disabilitato (spesso per le famose irragionevoli ragioni dei sistemisti delle intranet…), il che farebbe miseramente fallire la nostra logica di validazione. Purtroppo non c’è modo di evitare il post ma possiamo fare in modo che la logica di validazione imposta coni validatori continui a fare i suo dovere lato server con un semplice if sulla proprietà Page.IsValid:
1: protected void MyButton_Click(object sender, EventArgs e)
2: {
3: if (Page.IsValid)
4: {
5: this.MyLabel.Text = this.MyTextBox.Text;
6: }
7: }
E questo era per la serie: “lo so che per la maggior parte di voi è una banalità ma hai visto mai che qualcuno non lo sa…”
-- Michele