Server-Client-Server

Quando programmare diventa quasi un paradosso...

Siamo sempre nell'ambito web, e in questi giorni mi sto divertendo un sacco con Ajax, devo dire che bisogna pestarci un
po la testa.. ma il risultato può essere sorprendente.

Diciamo pure che questo è l'ennesima evoluzione del controllo AutoCompleteExtender.... di cui ho scritto qualcosa
qualche giorno fa.. (se tutto va bene l'altro ieri).

Il concetto di aiutare l'utente nella composizione di un dato, è cosa buona, è più complessa quando quanto dobbiamo
prelevare è il frutto di una query fatta su una vista con 20 colonne... e strano a dirsi è necessario mostrare tutti i 20
attributi, in un form.

Va da se che se mostro nella lista del AutoCompleteExtender tutti i 20 campi.. anche l'utente più sgamato si ritrova
nel pieno dell'incomprensibilità di ciò che sta leggendo.

Quindi torna utile pubblicare nella lista del AutoCompleteExtender solo lo stretto necessario ... e riportarlo al lato
Client.

Qui mi è sorto un dubbio .. e da qui come ritorno sul server ?? magia ?? Prestidirigilibizzazione ?? no...

patiamo dalla form e da ciò che contiene:

asp:ToolkitScriptManager ID="tsMain" runat="server" EnablePageMethods="True"
/asp:ToolkitScriptManager

asp:TextBox ID="txtrSearch" runat="server" Text=""/asp:TextBox

asp:AutoCompleteExtender ID="AutoCompleteExtenderDemo" runat="server"
TargetControlID="txtrSearch" ServiceMethod="GetCompletionList"
MinimumPrefixLength="1" CompletionInterval="1000"
EnableCaching="true" CompletionSetCount="10" OnClientItemSelected="ItemForSplit"
/asp:AutoCompleteExtender

asp:TextBox ID="txtDemo" runat="server" /asp:TextBox

In più ci servono un paio di cosette nel codeBheind...

[System.Web.Services.WebMethod]
public static string DoMore(string valueText)
{
return "Simple Test";
}

Rimane valida la GetCompletionList ( documentata qualche post fa.. )

[System.Web.Services.WebMethod]
public static string[] GetCompletionList(String prefixText, int count)
{
List suggetions = GetData(prefixText, count);
return suggetions.ToArray();
}

private static List GetSuggestions(string key, int count)
{
List suggestions = new List();

for (int i = 0; i < count; i++)
{
// la vostra logica di estrazione...
}
return suggestions;
}

E nella pagina .. ci servono queste due function ( nel aspx )

function ItemForSplit(source, eventArgs)
{
Value = eventArgs.get_value();
var rs = document.getElementById('txtrSearch');
var dm = document.getElementById('txtDemo');
rs.value = "";
PageMethods.DoMore(Value,OnCallComplete,null,dm);
}

function OnCallComplete(result,txtOutput,methodName)
{
txtOutput.value = result;
}

Questi scrip devono essere MESSI NEL BODY .. e non nella header .. se non no va... by Design...

Che cosa ottenete ???

che il Client richiede al Server i dati la prima volta con GetCompletionList, li usa e richiede per la seconda volta
i nuovi dati al Server...

Funziona che è una meraviglia..

Virtual (mente) parlando...

Consentire l'estensibilità/ereditarietà è sempre "Un bene" ?

Parafrasando l'idea di base "reduce-to-reuse" sono entrambe (estensibilità ed ereditarietà) "Un bene", perchè questo ci consente di scrivere meno codice, di usarlo meglio, di finalizzare lo scopo di una o più classi.

Tuttavia è necessario uno sforzo concreto in fase d'analisi.
Supponiamo che per applicativo venga richiesto di realizzare anagrafiche, attività è qualche funzionalità generica,
da rilasciare nella "Fase 1". Supponiamo quindi che per lo stesso applicativo sia prevista una "Fase 2" dove ogni azione
eseguita sulla anagrafica (insert/update/delete) debba essere scritta in un log.

In un primo momento al Team viene richiesto di implementare solo la "fase 1" e non venga presentata la "fase 2" .

Il team crea una serie di form per l'anagrafica con le azioni richieste che risulteranno non troppo diverse da queste..

protected void btnInsert()
{
// logiche di verifica dei campi...

// Altre logiche di verifica (doppi e/o simili)...

// codice per insert...
}

Dopo una serie di test il Team consegna l'applicativo... e solo dopo la consolidazione di quanto fatto, o l'accettazione
viene proposta al Team la "fase 2"...

In questo preciso caso eritidare i form implica una quasi completa revisione del codice già scritto ... con una conseguente
e onerosa perdita di tempo...

Se si facesse un passo in più... in fase d'analisi comunicando le due Fasi e comunicando che la seconda non è necessaria
subito...

il team potrebbe produrre per la "fase 1" qualcosa di simile a :

protected virtual void btnInsert(object sender, EventArgs e)
{
// logiche di verifica dei campi...

// Altre logiche di verifica (doppi e/o simili)...

// codice per insert...
}

e ( a fronte dell'aver ereditato la base .. )

protected override void btnInsert_Click(object sender, EventArgs e)
{
base.btnInsert_Click(sender, e);

// codice per Log
}

A fronte di un obbiettivo ben definito è possibile prendere delle decisioni che rendano più semplice il
raggiugimento dello stesso, ed in questo caso "semplice" implica anche Meno costoso...

OnRowDataBound

Le girdview hanno qualche piccola potenzialità nascosta.

Questo evento si scatena subito dopo aver invocato il DataBind() che ricordiamo essere l'associazione fra i dati e la gridview.
L'intercettazione dell' OnRowDataBound consente parecchie attività sfiziose.

L'evento è un GridViewRowEventHandler e i GridViewRowEventArgs sono davvero tanti.


System.Data.DataRowView dataValue = (System.Data.DataRowView)e.Row.DataItem;

if (dataValue != null) // nel caso dell'intestazione è NULL
{
if (dataValue.Row.ItemArray[_VerifyDeleted].ToString().ToLower() == "true")
{
e.Row.CssClass = "rL";
}
}

In questo caso specifico cambio lo stile di una Row se trovo un valore in un campo della dataTable ...

dataValue
(vista o presentazione dei dati) la riga non è ancora stata renderizzata.
dataValue.Row.ItemArray
(dati fisico o record rappresentato come Item Array]
e.Row
(riga che sta per essere renderizzata)

Il mio consiglio è di usare una gridview gestita a pagine ... con un quantitativo di righe più o meno basso.
Nell ordine dei 25 / 30 elementi, questo perchè OnRowDataBound è generato per ogni riga..
va da se che fare IO su 20 elementi ha un costo .. su 100 costa un bel po di più.

In questo evento ha delle buone potenzialità, è in qui che si possono aggiungere controlli e handler sui
controlli (tipo Button + Click, CheckBox ... e via e via) il limite rimane la creatività ed eventuali tempi di Render

Consentitemi ...

Clamore e stupore... ancora una volta chi opera le traduzioni merita un PLAUSO...

errore di runtime ASP.NET:
Solo i controlli del contenuto sono consentiti
direttamente in una pagina di contenuto che contiene
controlli del contenuto.

Come mi è capitato ???
Ho aggiunto uno script ad una MASTER PAGE FILE contenente uno script manager..
probabilmente ho messo lo script nel punto "sbagliato"... ma si può dare un messaggio così??

script language ="javascript"

/script
asp:Content ID="cpPrototype" ContentPlaceHolderID="cpHolder" runat="server"
(errore )

asp:Content ID="cpPrototype" ContentPlaceHolderID="cpHolder" runat="server"
script language ="javascript"

/script

tutto ok... mamma mia...

AutoCompleteExtender...

Sembra facile ma non è difficile...
Il nuovo ajax tool kit sembra semplice da usare ma non è sempre chiaro ne l'esempio di Ms, ne l'esito che otteniamo.

Decisamente inatteso è il comportamento dell' AutoComplete, ci sono esempi sparpagliati pseudo casuali, e come sempre
alcuni vanno.. altri no. E' possibile che chi scrive "si fa così" o "vi basta fare così" ( lo faccio anch'io... eh eh ) non documenti
l'ambiente in cui è stato fatto il test.

AjaxControlToolkit ver: 3.0.31106.0
System.Web:2.0.0.0
System.Web.Extensions:3.5.0.0

La vera domanda è perchè tutta sta zozzeria non è allineata ??? c'e' da chiederlo all'installer o a come dover
roccambolescamente installarsi tutto a mano... "fare una cosa fatta bene no ?"

cmq

1) createvi una nuova Web Solution ( non ho provato con il sito web)
2) assicuratevi di mettere...
Register Assembly="AjaxControlToolkit" Namespace="AjaxControlToolkit" TagPrefix="asp"
3) nel form..
form id="form1" runat="server"
asp:ToolkitScriptManager ID="ToolkitScriptManager1" runat="server"
/asp:ToolkitScriptManager

asp:TextBox ID="txtInOrderToComplete" runat="server" Text="" /asp:TextBox
asp:AutoCompleteExtender ID="AutoCompleteExtenderDemo" runat="server"
TargetControlID="txtInOrderToComplete" ServiceMethod="GetCompletionList"
MinimumPrefixLength="1" CompletionInterval="1000"
EnableCaching="true" CompletionSetCount="10"
/asp:AutoCompleteExtender
/form

Nota come al soliti il maggiore e il minore sto blog me li cassa !!

4)nel CodeBehind

[System.Web.Services.WebMethod]
public static string[] GetCompletionList(String prefixText, int count)
{
List suggetions = GetData(prefixText, count);
return suggetions.ToArray();
}


private static List GetSuggestions(string key, int count)
{
List suggestions = new List();

for (int i = 0; i < count; i++)
{
// la vostra logica di estrazione...
}
return suggestions;
}

Tecnicamente parlando non abbiamo implementato un web service per ottenere i dati .. chiaro che la logica
la si può spostare un po dove si vuole .. un po dove più fa comodo...

Ragioniamoci un po sopra...

Perchè statico ???
Perchè se non è statico non funziona.. certo come risposta fa un po acqua, ma sono convinto che la chiamata di un
web services ( o web method ) debba essere statica.

Perchè string[] e non List ???
Perchè il bind sulla lista ( o pseudo lista) che viene creata come output necessita una array di string[]

Perchè (String prefixText, int count) nella firma ???
Perchè la firma proviene dall'oggetto AutoCompleteExtender, e se non corrisponde... non va.

Posso cambiare ServiceMethod="GetCompletionList" ???
ServiceMethod="GetCompletionList" deve corrispondere al
public static string[] GetCompletionList(String prefixText, int count)

Bene questo è il quanto ..

Per altro non è necessario un update panel, ma funziona anche con lui.

buon divertimento.

C:\WINDOWS\system32\ctfmon.exe "Ma che cosa è?"

Parliamo giusto per qualche attimo ... che non fa male.

Qusto eseguibile E' DI MICROSOFT, ma ha un gemello detto anche il virus della "pen Drive" o "Chiavetta".
Più o meno l'abbiamo contratto tutti o se l'abbiamo non lo sappiamo.
Prendete la vostra penna usb infilatela nella vostra presa usb... e sbirciate se vi trovate un autorun.inf....
L'avete trovato, bene ... non troppo, ma bene.. ora apritelo con il NOTEPAD, non eseguitelo, editatelo,
e dentro troverte una zozzeria simile a

[autorun]
shellexecute=Recycled\ctfmon.exe
shell\Open(&0)\command=Recycled\ctfmon.exe
shell=Open(&0)

Come noterete .. "ctfmon.exe" è molto uguale a "ctfmon.exe" ma non sono la stessa cosa...
Il primo è un brillante Trojan il secondo è .. (suspance) un componente aggiuntivo di Office 2003
perfettamente INUTILE ai più.

C:\WINDOWS\system32\ctfmon.exe Questo ragazzaccio serve per l'input alternativo, che può essere
Riconoscimento Scrittura..
Sintesi e riconoscimento vocale..

Come sostengo può essere importante per chi ha dei deficit, ma dato che ms l'installa di default
supponendo che siamo tutti possibili portatori di Deficit... tuttavia non ti dice che lo fa....

La situazione finale è tristemente la seguente...
apri word ne parte uno ( che rimane appeso )
apri excel ne parte un'altro .. ( che strano ma vero rimane appeso )
apri outlook e caso strano (perchè usare uno di quelli appesi ) te ne apre un'altro che fa sempre bene...

Morale se aprite in un giorno 20 documenti vi trovate 20 ctfmon.exe...

Potete fare una cosa semplici crearvi una Restriction POLICY per evitare che parta... m alla fine vi ritrovate
l'event viewer pieno di zozzerie..

Oppure rimuoverlo
per il virus .. la cosa è semplice.. formattate la chiavetta.. e svuotate il cestino del pc e puf non ha persitenza...
Più che altro c'e' da tirarlo giù via Taskmanager...

per l'applicazione ms .... ci vuole un po di più, ma è semplice..
1) teskmanager e tirate giù tutti ctfmon ..
2) pannello di controllo / installazione applicazioni / Microsoft Office 2003
3) Scegliere "Cambia"
4) Aggiungi/Rimuovi caratteristiche
5) Fleggare Personalizzazione avanzata applicazioni
6) da Personalizzazione avanzata Espandere Microsoft Office

a questo punto cercate tutto quello che è inerente alla sintesi per il riconoscimento vocale o per gli input alternativi...
In più vi conviene rimuovere... il traduttore dal francese, dallo spagnolo, dal tedesco e tutte le altre lingue di cui
non avete bisogno ..


7) esegui / regedit
8) rimuovere da HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run\ Ctfmon.exe
9) esegui / regsvr32 /u msctf.dll

Fatto abbiamo finito ...

Wrappare che passione...

Dato che mi sarebbe tornato comodo crearmi un piccolo manager di sessione.. mi sono wrappato tutta la session.

Non mi ha dato di volta il cervello.. anche se ai più potrebbe sembrare. Per una questione di comodo mi trovo
a dover condividere quest'oggetto un po qua e un po la in un web application, e dato che non so e non posso
sapere chi o come aggiungerà elementi o chi o come li rimuoverà me la wrappo in toto, e poi mi occuperò di
aggiungere qualche metodo specializzato per la gestione in modo che chi aggiunge o toglie lo faccia come dico
IO !!

caso contrario sono dati "persi" o senza persistenza ..

cmq dato che potrebbe servire..

using System;
using System.Data;
using System.Collections;
using System.Configuration;
using System.Collections.Specialized;
using System.Web;
using System.Web.SessionState;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

namespace Life20.Commons
{
public class wrSession
{
private HttpSessionState _xSession = null;

#region Public Properties
public int CodePage
{
get { return _xSession.CodePage; }
}

public HttpSessionState Contents
{
get { return _xSession.Contents; }
}

public HttpCookieMode CookieMode
{
get { return _xSession.CookieMode; }
}
public int Count
{
get { return _xSession.Count; }
}

public bool IsCookieless
{
get { return _xSession.IsCookieless; }
}

public bool IsNewSession
{
get { return _xSession.IsNewSession; }
}

public bool IsReadOnly
{
get { return _xSession.IsReadOnly; }
}

public bool IsSynchronized
{
get { return _xSession.IsSynchronized; }
}

public NameObjectCollectionBase.KeysCollection Keys
{
get { return _xSession.Keys; }
}

public int LCID
{
get { return _xSession.LCID; }
}

public SessionStateMode Mode
{
get { return _xSession.Mode; }
}

public string SessionID
{
get { return _xSession.SessionID; }
}

public HttpStaticObjectsCollection StaticObjects
{
get { return _xSession.StaticObjects; }
}

public object SyncRoot
{
get { return _xSession.SyncRoot; }
}

public int Timeout
{
get { return _xSession.Timeout; }
set { _xSession.Timeout = value; }
}
#endregion

#region Builder
public wrSession(HttpSessionState crSession)
{
_xSession = crSession;
}
#endregion

#region Public Methods
public void Add(string _Name, object value )
{
_xSession.Add(_Name, value);
}

public void Abandon()
{
_xSession.Abandon();
}

public void Clear()
{
_xSession.Clear();
}

public void CopyTo(Array array, int index)
{
_xSession.CopyTo(array, index);
}

public override bool Equals(object obj)
{
return _xSession.Equals(obj);
}

public IEnumerator GetEnumerator()
{
return _xSession.GetEnumerator();
}

public override int GetHashCode()
{
return _xSession.GetHashCode();
}

public new Type GetType()
{
return _xSession.GetType();
}

public void Remove(string Name)
{
_xSession.Remove(Name);
}

public void RemoveAll()
{
_xSession.RemoveAll();
}

public void RemoveAt(int index)
{
_xSession.RemoveAt(index);
}

public override string ToString()
{
return _xSession.ToString();
}
#endregion
}
}


questa è la base.. senza naturalmente le mie specializzazioni...