su http://bitvector.tostring.it potete trovare gli ultimi articoli su:
- Sharepoint Business Data Catalog
- Problemi con metodologia SCRUM
- Sharepoint e i Content Type - prima parte
- Esito dell'evento tenuto a Bologna su MVC e tecnologia RIA
- Origini del pattern MVC
Su BitVector sto pubblicando varie guide per lo sviluppo di applicazioni di SharePoint:
Guide SharePoint
Buona lettura
Come ho già scritto nel mio blog, in data 16 Novembre, insieme a Ugo Lattanzi terrò una sessione su MVC.
Per più informazioni:
Ciao
Dopo un anno passato nei lidi di UGI, tento un’avventura in solitario dettata anche dalla mia partecipazione al progetto di Ugo Lattanzi, Dexter Blog Engine.
Spero dunque vogliate seguirmi, come avete già fatto in UGI, su BitVector:
http://bitvector.tostring.it
Grazie
Ormai è dal 24 luglio che non scrivo un post, causa batterie scariche.
Ma per settembre sono già pronto con una serie di post succosissimi, o almeno spero :D, e tante altre novità che sto portando
avanti con vari amici (Janky e Ugo in primis).
Quindi stay tuned e buone ferie
Come mi facevano notare, e mancata un pò di pubblicità sul primo articolo di OrangeDotNet
http://orangedotnet.org/blogs/sharepoint/archive/2009/07/10/esportare-una-tabella-su-un-sito-sharepoint.aspx
Nel primo post, su Sharepoint (argomento che in futuro mi troverà sempre più coinvolto), si tratta di un’esportazione di dati
da una List tramite LinqToXml. Sfruttando il Web Service di SharePoint e le query CAML.
Buona lettura
Ci sono molti modi per serializzare i dati.
Come serializzarli dipende da un pò di fattori come: voler condividere tipi o contratti, supportare i tipi .NET esistenti etc
DataContractSerializer
E’ il meccanismo di serializzazione di default, si trova sotto il namespace System.Runtime.Serialization.
Viene usata per i contratti da condividere i tipi CLR vengono mappati su tipi definiti in XSD, in questa maniera otteniamo un’alta interoperabilità.
Ciò significa, ad esempio, che il tipo System.String di un’applicazione .NET diventerà java.lang.String in un’applicazione Java.
Quando dobbiamo condividere un tipo complesso utilizzeremo il decoratore [DataContract], per marcare il tipo da serializzare e [DataMember] per marcare i membri
e le proprietà.
Code Snippet
- public class Employee
- {
- // ...
- private int employeeID;
- private string firstName;
- private string lastName;
- [DataMember]
- public int EmployeeID
- {
- get { return employeeID; }
- set { employeeID = value; }
- }
- [DataMember]
- public string FirstName
- {
- get { return firstName; }
- set { firstName = value; }
- }
- [DataMember]
- public string LastName
- {
- get { return lastName; }
- set { lastName = value; }
- }
- }
XSD Schema:
Code Snippet
- <GetDataResponse xmlns="http://tempuri.org/">
- < GetDataResult xmlns:a="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
- < a:EmployeeID>0</a:EmployeeID>
- < a:FirstName i:nil="true" />
- < a:LastName i:nil="true" />
- </ GetDataResult>
- </ GetDataResponse>
XML dati ottenuti:
Code Snippet
- <GetDataResponse xmlns="http://tempuri.org/">
- < GetDataResult xmlns:a="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
- < a:EmployeeID>1</a:EmployeeID>
- < a:FirstName>Salvo</a:FirstName>
- < a:LastName>Di Fazio</a:LastName>
- </ GetDataResult>
- </ GetDataResponse>
NetDataContractSerializer
Questo tipo di serializzazione viene usata quando cerchiamo un livello di fedeltà superiore tra client e server.
La classe NetDataContractSerializer ha un livello di fedeltà maggiore rispetto alla DataContractSerializer perchè, nella fase di serializzazione, vengono inseriti ulteriori informazioni inerenti
ai tipi CLR e alle reference; oltre a questo, tra le due, non vi è alcuna differenza.
Pertanto la NetDataContractSerializer può essere utilizzata solo se le estremità di serializzazione e deserializzazione condividono gli stessi tipi CLR.
Ecco un esempio di serializzazione:
Code Snippet
- static void Main()
- {
- Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
- FileStream fs = new FileStream("esempio.xml", FileMode.Create);
- NetDataContractSerializer ser = new NetDataContractSerializer();
- ser.WriteObject(fs, e);
- fs.Close();
- }
ed eccone il risultato inerente solamente all’oggetto scambiato:
Code Snippet
- <Employee z:Id="1" z:Type="ConsoleApplication1.ServiceReference1.Employee" z:Assembly="ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
- < EmployeeID>1</EmployeeID>
- < FirstName z:Id="2">Salvo</FirstName>
- < LastName z:Id="3">Di Fazio</LastName>
- </ Employee>
XmlSerializer
Questo meccanismo di serializzazione è presente dal .NET 2.
Ci sono molti vantaggi nell’usare l’XmlSerializer: supporto per i tipi esistenti di .NET, compatibilità con gli ASP.NET Web Services e la creazione di un output XML da poter condividere.
WCF supporta l’XmlSerializer così da poter lavorare con i tipi esistenti a differenza del DataContractSerializer che è usato per i nuovi.
Si possono usare 3 approcci per lavorare con questa serializzazione:
- Quella di default, creando un oggetto e usando questo per scrivere i dati
- Usare gli attributi: [XmlElement] e [XmlAttribute] (e altri attributi)
- Usare l’interfaccia IXmlSerializable per customizzare tutto il processo di serializzazione
Ecco un esempio:
Code Snippet
- public class Employee
- {
- // ...
- private int employeeID;
- private string firstName;
- private string lastName;
- public int EmployeeID
- {
- get { return employeeID; }
- set { employeeID = value; }
- }
- public string FirstName
- {
- get { return firstName; }
- set { firstName = value; }
- }
- public string LastName
- {
- get { return lastName; }
- set { lastName = value; }
- }
- }
Code Snippet
- static void Main()
- {
- Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
- FileStream fs = new FileStream("esempio.xml", FileMode.Create);
- XmlSerializer ser = new XmlSerializer(typeof(Employee));
- ser.WriteObject(fs, e);
- fs.Close();
- }
Senza la classe XmlSerializer vista la nuova implementazione di Employee, questa non sarebbe serializzabile.
L’attributo [XmlSerializerFormat] può essere usato per obbligare WCF ad usare l’XmlSerializer:
Code Snippet
- [ServiceContract]
- [XmlSerializerFormat]
- public interface IEmployeeXml
- {
- [OperationContract]
- Employee GetData();
- }
DataContractJsonSerializer
Supporta l’uso di JavaScript Object Notation (JSON).
Questo tipo di serializzazione è ottima se voltete chiare il vostro metodo WCF da una Web Application che utilizza AJAX o Silverlight.
Viene usata quando abilitiamo WebScriptEnablingBehavior o WebHttpBehavior e configurato l’encoding JSON.
Quando gli endpoint sono così configurati, istruiscono WCF a supportare servizi di tipo REST/POX.
Code Snippet
- static void Main()
- {
- Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
- FileStream fs = new FileStream("esempio.xml", FileMode.Create);
- DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Employee));
- ser.WriteObject(fs, e);
- fs.Close();
- }
il risultato sarà:
Code Snippet
- {"EmployeeID":1,"FirstName":"Salvo","LastName":"Di Fazio"}