Utilizzo di XmlIgnore su classi parziali generate

Question

Ho una classe SQL LINQ 2 che vorrei esporre tramite un servizio web. Ci sono alcune proprietà interne che non voglio essere disponibile.

Normalmente lancerò [XmlIgnore], ma poiché le proprietà sono nella metà generata, non posso farlo.

Ho cercato di utilizzare MetadataType dopo this post, che sembra dovrebbe consentirmi di definire gli attributi di proprietà in un'altra classe.

Il mio codice simile a questa:

[MetadataType(typeof(ProspectMetaData))] 
public partial class Prospect : ApplicationBaseObject 
{ 
} 

public class ProspectMetaData 
{ 
    [XmlIgnore] 
    public object CreatedDateTime { get; set; } 

    [XmlIgnore] 
    public object AmendedDateTime { get; set; } 

    [XmlIgnore] 
    public object Timestamp { get; set; } 
} 

sto riferimento a questo attraverso un servizio Web ASP.NET da un progetto Silverlight.

Il problema è che gli attributi [XmlIgnore] vengono ignorati, quelle proprietà vengono inviate tramite.

Qualcuno ha qualche idea di cosa potrebbe andare storto qui? e quale potrebbe essere il modo migliore per farlo?

Answer 1

AFAIK, MetadataTypeAttribute non è supportato da XmlSerializer (anche se sarebbe bello, non ho mai controllato). E come dici tu, non puoi aggiungere attributi membro in una classe parziale.

Una possibilità potrebbe essere quella di rendere le proprietà generati non pubblici (private, protected o internal) - e denominarlo qualcosa come TimestampStorage (etc) - poi ri-esporre (nella classe parziale) sulla API pubblica:

[XmlIgnore] 
public object Timestamp { 
    get {return TimestampStorage; } 
    set {TimestampStorage = value; } 
} 
// and other properties 

(dal XmlSerializer guarda solo alla API pubblica). Il problema più grande qui è che le query LINQ-to-SQL (Where ecc.) Funzioneranno solo contro le colonne generate (TimestampStorage ecc.). Ho usato questo approccio in precedenza con il membro come internal, consentendo alla mia classe DAL di utilizzare la proprietà internal ... ma è un po 'un fudge.

Answer 2

Sono d'accordo con Marc. La cosa più semplice da fare è contrassegnarli internamente. Se lo si desidera, è possibile esporli nuovamente nella classe parziale con [XmlIgnore]. A proposito, è possibile controllare l'accessibilità delle proprietà nel designer linq2sql. Vai alla finestra di dialogo delle proprietà e vedrai un posto per impostarle

Answer 3

Puoi farlo passando il tuo XmlAttributeOverrides a XmlSerializer, in XmlAttributeOverrides puoi cambiare XmlIgnore a vero per i campi/proprietà che desideri senza toccando il DBML codice generato e funziona come un fascino, utilizzare le stesse sostituzioni per deserializzare così ...

Refer this link per ulteriori informazioni

// Create the XmlAttributeOverrides and XmlAttributes objects. 
    XmlAttributeOverrides xOver = new XmlAttributeOverrides(); 

    XmlAttributes attrs = new XmlAttributes(); 
    attrs.XmlIgnore = true; 

    /* Setting XmlIgnore to true overrides the XmlIgnoreAttribute 
     applied to the following fields. Thus it will be serialized.*/ 
    xOver.Add(typeof(Prospect), "CreatedDateTime", attrs); 
    xOver.Add(typeof(Prospect), "AmendedDateTime", attrs); 
    xOver.Add(typeof(Prospect), "Timestamp", attrs); 

    XmlSerializer xSer = new XmlSerializer(typeof(Prospect), xOver); 
    TextWriter writer = new StreamWriter(outputFilePath); 
    xSer.Serialize(writer, object);