public void Remove(XmlElementAttribute attribute);
public bool Contains(XmlElementAttribute attribute);
public int IndexOf(XmlElementAttribute attribute);
private bool genera_xml(string percorso, string nome_file)
{
bool esito = false;
try
{
FatturaElettronicaXMLNodes nodoPrincipale = new FatturaElettronicaXMLNodes();
FatturaElettronicaHeader overviewHeader = new FatturaElettronicaHeader();
DatiTrasmissione datiTrasmissione = new DatiTrasmissione();
IdTrasmittente idTrasmittente_111 = new IdTrasmittente();
idTrasmittente_111.IdPaese = "IT";
idTrasmittente_111.IdCodice = "01234567890";
datiTrasmissione.IdTrasmittente = idTrasmittente_111;
datiTrasmissione.ProgressivoInvio = "00001";
datiTrasmissione.FormatoTrasmissione = "FPR12";
datiTrasmissione.CodiceDestinatario = "ABC1234";
ContattiTrasmittente contattiTrasmittente_115 = new ContattiTrasmittente();
contattiTrasmittente_115.Telefono = "";
contattiTrasmittente_115.Email = "";
datiTrasmissione.ContattiTrasmittente = contattiTrasmittente_115;
datiTrasmissione.PECDestinatario = "";
overviewHeader.DatiTrasmissione = datiTrasmissione;
CedentePrestatore cedentePrestatore = new CedentePrestatore();
DatiAnagrafici datiAnagrafici_121 = new DatiAnagrafici();
IdFiscaleIVA idFiscaleIVA_121 = new IdFiscaleIVA();
idFiscaleIVA_121.IdPaese = "IT";
idFiscaleIVA_121.IdCodice = "01234567890";
datiAnagrafici_121.IdFiscaleIVA = idFiscaleIVA_121;
datiAnagrafici_121.CodiceFiscale = "";
Anagrafica anagrafica_121 = new Anagrafica();
anagrafica_121.Denominazione = "SOCIETA' ALPHA SRL";
anagrafica_121.Nome = "";
anagrafica_121.Cognome = "";
anagrafica_121.Titolo = "";
anagrafica_121.CodEORI = "";
datiAnagrafici_121.Anagrafica = anagrafica_121;
datiAnagrafici_121.AlboProfessionale = "";
datiAnagrafici_121.ProvinciaAlbo = "";
datiAnagrafici_121.NumeroIscrizioneAlbo = "";
datiAnagrafici_121.DataIscrizioneAlbo = "";
datiAnagrafici_121.RegimeFiscale = "RF19";
cedentePrestatore.DatiAnagrafici = datiAnagrafici_121;
Sede sede_122 = new Sede();
sede_122.Indirizzo = "VIALE ROMA";
sede_122.NumeroCivico = "543";
sede_122.CAP = "07100";
sede_122.Comune = "SASSARI";
sede_122.Provincia = "SS";
sede_122.Nazione = "IT";
cedentePrestatore.Sede = sede_122;
StabileOrganizzazione stabileOrganizzazione_123 = new StabileOrganizzazione();
stabileOrganizzazione_123.Indirizzo = "";
stabileOrganizzazione_123.NumeroCivico = "";
stabileOrganizzazione_123.CAP = "";
stabileOrganizzazione_123.Comune = "";
stabileOrganizzazione_123.Provincia = "";
stabileOrganizzazione_123.Nazione = "";
cedentePrestatore.StabileOrganizzazione = stabileOrganizzazione_123;
IscrizioneREA iscrizioneREA_124 = new IscrizioneREA();
iscrizioneREA_124.Ufficio = "";
iscrizioneREA_124.NumeroREA = "";
iscrizioneREA_124.CapitaleSociale = "";
iscrizioneREA_124.SocioUnico = "";
iscrizioneREA_124.StatoLiquidazione = "";
cedentePrestatore.IscrizioneREA = iscrizioneREA_124;
Contatti contatti_125 = new Contatti();
contatti_125.Telefono = "";
contatti_125.Fax = "";
contatti_125.Email = "";
cedentePrestatore.Contatti = contatti_125;
cedentePrestatore.RiferimentoAmministrazione = "";
overviewHeader.CedentePrestatore = cedentePrestatore;
RappresentanteFiscale rappresentanteFiscale = new RappresentanteFiscale();
DatiAnagrafici datiAnagrafici_131 = new DatiAnagrafici();
IdFiscaleIVA idFiscaleIVA_131 = new IdFiscaleIVA();
idFiscaleIVA_131.IdPaese = "";
idFiscaleIVA_131.IdPaese = "";
datiAnagrafici_131.IdFiscaleIVA = idFiscaleIVA_131;
datiAnagrafici_131.CodiceFiscale = "";
Anagrafica anagrafica_131 = new Anagrafica();
anagrafica_131.Denominazione = "";
anagrafica_131.Nome = "";
anagrafica_131.Cognome = "";
anagrafica_131.Titolo = "";
anagrafica_131.CodEORI = "";
datiAnagrafici_131.Anagrafica = anagrafica_131;
rappresentanteFiscale.DatiAnagrafici = datiAnagrafici_131;
overviewHeader.RappresentanteFiscale = rappresentanteFiscale;
CessionarioCommittente cessionarioCommittente = new CessionarioCommittente();
DatiAnagrafici datiAnagrafici_141 = new DatiAnagrafici();
IdFiscaleIVA idFiscaleIVA_141 = new IdFiscaleIVA();
idFiscaleIVA_141.IdPaese = "";
idFiscaleIVA_141.IdCodice = "";
datiAnagrafici_141.IdFiscaleIVA = idFiscaleIVA_141;
datiAnagrafici_141.CodiceFiscale = "09876543210";
Anagrafica anagrafica_141 = new Anagrafica();
anagrafica_141.Denominazione = "AMMINISTRAZIONE BETA";
anagrafica_141.Nome = "";
anagrafica_141.Cognome = "";
anagrafica_141.Titolo = "";
anagrafica_141.CodEORI = "";
datiAnagrafici_141.Anagrafica = anagrafica_141;
cessionarioCommittente.DatiAnagrafici = datiAnagrafici_141;
Sede sede_142 = new Sede();
sede_142.Indirizzo = "VIA TORINO";
sede_142.NumeroCivico = "38";
sede_142.CAP = "00145";
sede_142.Comune = "ROMA";
sede_142.Provincia = "RM";
sede_142.Nazione = "IT";
cessionarioCommittente.Sede = sede_142;
StabileOrganizzazione stabileOrganiccazione_143 = new StabileOrganizzazione();
stabileOrganiccazione_143.Indirizzo = "";
stabileOrganiccazione_143.NumeroCivico = "";
stabileOrganiccazione_143.CAP = "";
stabileOrganiccazione_143.Comune = "";
stabileOrganiccazione_143.Provincia = "";
stabileOrganiccazione_143.Nazione = "";
cessionarioCommittente.StabileOrganizzazione = stabileOrganiccazione_143;
RappresentanteFiscale rappresentanteFiscale_144 = new RappresentanteFiscale();
DatiAnagrafici datiAnagrafici_144 = new DatiAnagrafici();
IdFiscaleIVA idFiscaleIVA_144 = new IdFiscaleIVA();
idFiscaleIVA_144.IdPaese = "";
idFiscaleIVA_144.IdCodice = "";
datiAnagrafici_144.IdFiscaleIVA = idFiscaleIVA_144;
Anagrafica anagrafica_144 = new Anagrafica();
anagrafica_144.Denominazione = "";
anagrafica_144.Nome = "";
anagrafica_144.Cognome = "";
datiAnagrafici_144.Anagrafica = anagrafica_144;
rappresentanteFiscale_144.DatiAnagrafici = datiAnagrafici_144;
overviewHeader.CessionarioCommittente = cessionarioCommittente;
TerzoIntermediarioOSoggettoEmittente terzoIntermediarioOSoggettoEmittente = new TerzoIntermediarioOSoggettoEmittente();
DatiAnagrafici datiAnagrafici_151 = new DatiAnagrafici();
IdFiscaleIVA idFiscaleIVA_151 = new IdFiscaleIVA();
idFiscaleIVA_151.IdPaese = "";
idFiscaleIVA_151.IdCodice = "";
datiAnagrafici_151.IdFiscaleIVA = idFiscaleIVA_151;
datiAnagrafici_151.CodiceFiscale = "";
datiAnagrafici_151.CodiceFiscale = "";
Anagrafica anagrafica_151 = new Anagrafica();
anagrafica_151.Denominazione = "";
anagrafica_151.Nome = "";
anagrafica_151.Cognome = "";
anagrafica_151.Titolo = "";
anagrafica_151.CodEORI = "";
datiAnagrafici_151.Anagrafica = anagrafica_151;
overviewHeader.TerzoIntermediarioOSoggettoEmittente = terzoIntermediarioOSoggettoEmittente;
overviewHeader.SoggettoEmittente = "";
FatturaElettronicaBody overviewBody = new FatturaElettronicaBody();
DatiGenerali datiGenerali = new DatiGenerali();
DatiGeneraliDocumento datiGeneraliDocumento = new DatiGeneraliDocumento();
datiGeneraliDocumento.TipoDocumento = "TD01";
datiGeneraliDocumento.Divisa = "EUR";
datiGeneraliDocumento.Data = "2017-01-18";
datiGeneraliDocumento.Numero = "123";
DatiRitenuta datiRitenuta = new DatiRitenuta();
datiRitenuta.TipoRitenuta = "";
datiRitenuta.ImportoRitenuta = "";
datiRitenuta.AliquotaRitenuta = "";
datiRitenuta.CausalePagamento = "";
datiGeneraliDocumento.DatiRitenuta = datiRitenuta;
DatiBollo datiBollo = new DatiBollo();
datiBollo.BolloVirtuale = "";
datiBollo.ImportoBollo = "";
datiGeneraliDocumento.DatiBollo = datiBollo;
DatiCassaPrevidenziale datiCassaPrevidenziale = new DatiCassaPrevidenziale();
List <DatiCassaPrevidenziale> datiCassaPrevidenzialeList = new List <DatiCassaPrevidenziale>();
datiCassaPrevidenziale.TipoCassa = "";
datiCassaPrevidenziale.AlCassa = "";
datiCassaPrevidenziale.ImportoContributoCassa = "";
datiCassaPrevidenziale.ImponibileCassa = "";
datiCassaPrevidenziale.AliquotaIVA = "";
datiCassaPrevidenziale.Ritenuta = "";
datiCassaPrevidenziale.Natura = "";
datiCassaPrevidenziale.RiferimentoAmministrazione = "";
datiCassaPrevidenzialeList.Add(datiCassaPrevidenziale);
datiGeneraliDocumento.DatiCassaPrevidenziale = datiCassaPrevidenzialeList;
ScontoMaggiorazione scontoMaggiorazione = new ScontoMaggiorazione();
List <ScontoMaggiorazione> scontoMaggiorazioneList = new List <ScontoMaggiorazione>();
scontoMaggiorazione.Tipo = "";
scontoMaggiorazione.Percentuale = "";
scontoMaggiorazione.Importo = "";
scontoMaggiorazioneList.Add(scontoMaggiorazione);
datiGeneraliDocumento.ScontoMaggiorazione = scontoMaggiorazioneList;
datiGeneraliDocumento.ImportoTotaleDocumento = "";
datiGeneraliDocumento.Arrotondamento = "";
datiGeneraliDocumento.Causale = "";
datiGeneraliDocumento.Art73 = "";
datiGenerali.DatiGeneraliDocumento = datiGeneraliDocumento;
DatiOrdineAcquisto datiOrdineAcquisto = new DatiOrdineAcquisto();
List <DatiOrdineAcquisto> datiOrdineAcquistoList = new List <DatiOrdineAcquisto>();
datiOrdineAcquisto.RiferimentoNumeroLinea = "1";
datiOrdineAcquisto.IdDocumento = "66685";
datiOrdineAcquisto.Data = "2016-09-0";
datiOrdineAcquisto.NumItem = "";
datiOrdineAcquisto.CodiceCommessaConvenzione = "";
datiOrdineAcquisto.CodiceCUP = "";
datiOrdineAcquisto.CodiceCIG = "";
datiOrdineAcquistoList.Add(datiOrdineAcquisto);
datiGenerali.DatiOrdineAcquisto = datiOrdineAcquistoList;
DatiContratto datiContratto = new DatiContratto();
List <DatiContratto> datiContrattoList = new List <DatiContratto>();
datiContratto.RiferimentoNumeroLinea = "";
datiContratto.IdDocumento = "";
datiContratto.Data = "";
datiContratto.NumItem = "";
datiContratto.CodiceCommessaConvenzione = "";
datiContratto.CodiceCUP = "";
datiContratto.CodiceCIG = "";
datiContrattoList.Add(datiContratto);
datiGenerali.DatiContratto = datiContrattoList;
DatiConvenzione datiConvenzione = new DatiConvenzione();
List <DatiConvenzione> datiConvenzioneList = new List <DatiConvenzione>();
datiConvenzione.RiferimentoNumeroLinea = "";
datiConvenzione.IdDocumento = "";
datiConvenzione.Data = "";
datiConvenzione.NumItem = "";
datiConvenzione.CodiceCommessaConvenzione = "";
datiConvenzione.CodiceCUP = "";
datiConvenzione.CodiceCIG = "";
datiConvenzioneList.Add(datiConvenzione);
datiGenerali.DatiConvenzione = datiConvenzioneList;
DatiRicezione datiRicezione = new DatiRicezione();
List <DatiRicezione> datiRicezioneList = new List <DatiRicezione>();
datiRicezione.RiferimentoNumeroLinea = "";
datiRicezione.IdDocumento = "";
datiRicezione.Data = "";
datiRicezione.NumItem = "";
datiRicezione.CodiceCommessaConvenzione = "";
datiRicezione.CodiceCUP = "";
datiRicezione.CodiceCIG = "";
datiRicezioneList.Add(datiRicezione);
datiGenerali.DatiRicezione = datiRicezioneList;
DatiFattureCollegate datiFattureCollegate = new DatiFattureCollegate();
List <DatiFattureCollegate> datiFattureCollegateList = new List <DatiFattureCollegate>();
datiFattureCollegate.RiferimentoNumeroLinea = "";
datiFattureCollegate.IdDocumento = "";
datiFattureCollegate.Data = "";
datiFattureCollegate.NumItem = "";
datiFattureCollegate.CodiceCommessaConvenzione = "";
datiFattureCollegate.CodiceCUP = "";
datiFattureCollegate.CodiceCIG = "";
datiFattureCollegateList.Add(datiFattureCollegate);
datiGenerali.DatiFattureCollegate = datiFattureCollegateList;
DatiSAL datiSAL = new DatiSAL();
List <DatiSAL> datiSALList = new List <DatiSAL>();
datiSAL.RiferimentoFase = "";
datiSALList.Add(datiSAL);
datiGenerali.DatiSAL = datiSALList;
DatiDDT datiDDT = new DatiDDT();
List <DatiDDT> datiDDTList = new List <DatiDDT>();
datiDDT.NumeroDDT = "";
datiDDT.DataDDT = "";
datiDDT.RiferimentoNumeroLinea = "";
datiDDTList.Add(datiDDT);
datiGenerali.DatiDDT = datiDDTList;
DatiTrasporto datiTrasporto = new DatiTrasporto();
DatiAnagraficiVettore datiAnagraficiVettore = new DatiAnagraficiVettore();
IdFiscaleIVA idFiscaleIva = new IdFiscaleIVA();
idFiscaleIva.IdCodice = "";
idFiscaleIva.IdPaese = "";
datiAnagraficiVettore.IdFiscaleIVA = idFiscaleIva;
datiAnagraficiVettore.CodiceFiscale = "";
Anagrafica anagraficaVettore = new Anagrafica();
anagraficaVettore.Denominazione = "";
anagraficaVettore.Nome = "";
anagraficaVettore.Cognome = "";
anagraficaVettore.Titolo = "";
anagraficaVettore.CodEORI = "";
datiAnagraficiVettore.Anagrafica = anagraficaVettore;
datiAnagraficiVettore.NumeroLicenzaGuida = "";
datiTrasporto.MezzoTrasporto = "";
datiTrasporto.CausaleTrasporto = "";
datiTrasporto.NumeroColli = "";
datiTrasporto.Descrizione = "";
datiTrasporto.UnitaMisuraPeso = "";
datiTrasporto.PesoLordo = "";
datiTrasporto.PesoNetto = "";
datiTrasporto.DataOraRitiro = "";
datiTrasporto.DataInizioTrasporto = "";
datiTrasporto.TipoResa = "";
IndirizzoResa indirizzoResa = new IndirizzoResa();
indirizzoResa.Indirizzo = "";
indirizzoResa.NumeroCivico = "";
indirizzoResa.CAP = "";
indirizzoResa.Comune = "";
indirizzoResa.Provincia = "";
indirizzoResa.Nazione = "";
datiTrasporto.IndirizzoResa = indirizzoResa;
datiTrasporto.DataOraConsegna = "";
datiGenerali.DatiTrasporto = datiTrasporto;
FatturaPrincipale fatturaPrincipale = new FatturaPrincipale();
fatturaPrincipale.NumeroFatturaPrincipale = "";
fatturaPrincipale.DataFatturaPrincipale = "";
datiGenerali.FatturaPrincipale = fatturaPrincipale;
overviewBody.DatiGenerali = datiGenerali;
DatiBeniServizi datiBeniServizi = new DatiBeniServizi();
DettaglioLinee dettaglioLinee = new DettaglioLinee();
List <DettaglioLinee> dettaglioLineeList = new List <DettaglioLinee>();
dettaglioLinee.NumeroLinea = "";
dettaglioLinee.TipoCessionePrestazione = "";
CodiceArticolo codiceArticolo = new CodiceArticolo();
codiceArticolo.CodiceTipo = "";
codiceArticolo.CodiceValore = "";
dettaglioLinee.CodiceArticolo = codiceArticolo;
dettaglioLinee.Descrizione = "";
dettaglioLinee.Quantita = "";
dettaglioLinee.UnitaMisura = "";
dettaglioLinee.DataInizioPeriodo = "";
dettaglioLinee.DataFinePeriodo = "";
dettaglioLinee.PrezzoUnitario = "";
ScontoMaggiorazione scontoMaggiorazione_221 = new ScontoMaggiorazione();
scontoMaggiorazione_221.Tipo = "";
scontoMaggiorazione_221.Percentuale = "";
scontoMaggiorazione_221.Importo = "";
dettaglioLinee.ScontoMaggiorazione = scontoMaggiorazione_221;
dettaglioLinee.PrezzoTotale = "";
dettaglioLinee.AliquotaIVA = "";
dettaglioLinee.Ritenuta = "";
dettaglioLinee.Natura = "";
dettaglioLinee.RiferimentoAmministrazione = "";
AltriDatiGestionali altriDatiGestionali = new AltriDatiGestionali();
altriDatiGestionali.TipoDato = "";
altriDatiGestionali.RiferimentoTesto = "";
altriDatiGestionali.RiferimentoNumero = "";
altriDatiGestionali.RiferimentoData = "";
dettaglioLinee.AltriDatiGestionali = altriDatiGestionali;
dettaglioLineeList.Add(dettaglioLinee);
datiBeniServizi.DettaglioLinee = dettaglioLineeList;
DatiRiepilogo datiRiepilogo = new DatiRiepilogo();
List <DatiRiepilogo> datiRiepilogoList = new List <DatiRiepilogo>();
datiRiepilogo.AliquotaIVA = "";
datiRiepilogo.Natura = "";
datiRiepilogo.SpeseAccessorie = "";
datiRiepilogo.Arrotondamento = "";
datiRiepilogo.ImponibileImporto = "";
datiRiepilogo.Imposta = "";
datiRiepilogo.EsigibilitaIVA = "";
datiRiepilogo.RiferimentoNormativo = "";
datiRiepilogoList.Add(datiRiepilogo);
datiBeniServizi.DatiRiepilogo = datiRiepilogoList;
overviewBody.DatiBeniServizi = datiBeniServizi;
DatiVeicoli datiVeicoli = new DatiVeicoli();
datiVeicoli.Data = "";
datiVeicoli.TotalePercorso = "";
overviewBody.DatiVeicoli = datiVeicoli;
DatiPagamento datiPagamento = new DatiPagamento();
datiPagamento.CondizioniPagamento = "";
DettaglioPagamento dettaglioPagamento = new DettaglioPagamento();
dettaglioPagamento.Beneficiario = "";
dettaglioPagamento.ModalitaPagamento = "";
dettaglioPagamento.DataRiferimentoTerminiPagamento = "";
dettaglioPagamento.GiorniTerminiPagamento = "";
dettaglioPagamento.DataScadenzaPagamento = "";
dettaglioPagamento.ImportoPagamento = "";
dettaglioPagamento.CodUfficioPostale = "";
dettaglioPagamento.CognomeQuietanzante = "";
dettaglioPagamento.NomeQuietanzante = "";
dettaglioPagamento.CFQuietanzante = "";
dettaglioPagamento.TitoloQuietanzante = "";
dettaglioPagamento.IstitutoFinanziario = "";
dettaglioPagamento.IBAN = "";
dettaglioPagamento.ABI = "";
dettaglioPagamento.CAB = "";
dettaglioPagamento.BIC = "";
dettaglioPagamento.ScontoPagamentoAnticipato = "";
dettaglioPagamento.DataLimitePagamentoAnticipato = "";
dettaglioPagamento.PenalitaPagamentiRitardati = "";
dettaglioPagamento.DataDecorrenzaPenale = "";
dettaglioPagamento.CodicePagamento = "";
datiPagamento.DettaglioPagamento = dettaglioPagamento;
overviewBody.DatiPagamento = datiPagamento;
Allegati allegati = new Allegati();
allegati.NomeAttachment = "";
allegati.AlgoritmoCompressione = "";
allegati.FormatoAttachment = "";
allegati.DescrizioneAttachment = "";
allegati.Attachment = "";
overviewBody.Allegati = allegati;
nodoPrincipale.FatturaElettronicaHeader = overviewHeader;
nodoPrincipale.FatturaElettronicaBody = overviewBody;
XmlRootAttribute XmlRoot = new XmlRootAttribute();
XmlRoot.Namespace = "http://www.fatturapa.gov.it/sdi/fatturapa/v1.2";
XmlAttributes myxmlAttribute = new XmlAttributes();
myxmlAttribute.XmlRoot = XmlRoot;
XmlAttributeOverrides xmlAttributeOverrides = new XmlAttributeOverrides();
xmlAttributeOverrides.Add(typeof(FatturaElettronicaXMLNodes), myxmlAttribute);
XmlAttributes emptyNsAttribute = new XmlAttributes();
XmlElementAttribute xElement1 = new XmlElementAttribute();
xElement1.Namespace = "";
emptyNsAttribute.XmlElements.Add(xElement1);
xmlAttributeOverrides.Add(typeof(FatturaElettronicaXMLNodes), "FatturaElettronicaHeader", emptyNsAttribute);
xmlAttributeOverrides.Add(typeof(FatturaElettronicaXMLNodes), "FatturaElettronicaBody", emptyNsAttribute);
nodoPrincipale.versione = "FPA12";
XmlSerializer ser = new XmlSerializer(nodoPrincipale.GetType(), xmlAttributeOverrides);
ser = new XmlSerializer(nodoPrincipale.GetType(), new XmlRootAttribute("pX"));
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add("ds", "http://www.w3.org/2000/09/xmldsig#");
ns.Add("p", "http://ivaservizi.agenziaentrate.gov.it/docs/xsd/fatture/v1.2");
ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
var path = percorso + nome_file;
System.IO.FileStream file = System.IO.File.Create(path);
ser.Serialize(new System.IO.StreamWriter(file, new System.Text.UTF8Encoding()), nodoPrincipale, ns);
file.Close();
string delimiterToBeReplaced = "pX";
string newDelimiter = "p:FatturaElettronica";
string contents = System.IO.File.ReadAllText(path);
contents = contents.Replace(delimiterToBeReplaced, newDelimiter);
System.IO.File.WriteAllText(path, contents);
esito = true;
}
catch (Exception ex)
{
string eccezione = ex.ToString();
return(esito);
}
return(esito);
}
/// <summary>
/// Creates a new xml structure from element
/// </summary>
public SwaggerXmlInfo(XmlElementAttribute elementInfo)
{
this.Name = elementInfo.ElementName;
this.Namespace = elementInfo.Namespace;
}
// Methods
public int Add(XmlElementAttribute attribute)
{
}
/// <summary>
/// Devuelve un booleano indicando que el atributo es de serializacion en xml
/// </summary>
/// <param name="att"></param>
/// <returns></returns>
protected virtual bool InitializeAttribute(Attribute att)
{
bool output = false;
if (att is XmlElementValueAttribute)
{
XmlElementValueAttribute a = att as XmlElementValueAttribute;
if (a.Type == null)
{
if (TypeHelper.IsValueType(a.Type))
{
this.DefaultAttributeName = a.AttributeName;
}
this.DefaultElementName = a.ElementName;
}
else
{
if (TypeHelper.IsValueType(a.Type))
{
this.AddAttributeToTypeMap(a.AttributeName, a.Type);
this.AddTypeToAttributeMap(a.Type, a.AttributeName);
}
this.AddElementToTypeMap(a.ElementName, a.Type);
this.AddTypeToElementMap(a.Type, a.ElementName);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlContentAttribute)
{
this.AddAttribute(att);
output = true;
}
else if (att is XmlDateTimeFormatAttribute)
{
this.AddAttribute(att);
output = true;
}
else if (att is XmlTimeSpanFormatAttribute)
{
this.AddAttribute(att);
output = true;
}
else if (att is XmlNumericFormatAttribute)
{
this.AddAttribute(att);
output = true;
}
else if (att is XmlOrderAttribute)
{
this.Order = ((XmlOrderAttribute)att).Order;
}
else if (att is XmlIncludeAttribute)
{
this.IncludeTypes.Add(((XmlIncludeAttribute)att).Type);
}
else if (att is XmlArrayAttribute)
{
this.DefaultElementName = ((XmlArrayAttribute)att).ElementName;
output = true;
}
else if (att is XmlInlineArrayAttributeAttribute)
{
XmlInlineArrayAttributeAttribute a = att as XmlInlineArrayAttributeAttribute;
if (a.Type == null)
{
this.DefaultAttributeName = a.AttributeName;
this.DefaultElementName = null;
if (!string.IsNullOrEmpty(a.ItemSeparator))
{
this.AddAttribute(a);
}
}
else
{
Type itemType = a.Type.GetElementType();
if (itemType == null)
{
throw new Exception("No es posible inferir el tipo del item del array de la propiedad " + this.PropertyName + " del tipo " + this.OwnerType.Name);
}
if (this.PropertyType.IsArray)
{
Type dcItemType = this.PropertyType.GetElementType();
if (dcItemType == null || !dcItemType.Equals(itemType))
{
throw new Exception("El tipo del item del array declarado en el atributo XmlInlineArrayAttributeAttribute es distinto al tipo del item del array de la propiedad " + this.PropertyName + " del tipo " + this.OwnerType.Name);
}
}
//agrego el tipo de el arrar..
this.AddAttributeToTypeMap(a.AttributeName, a.Type);
this.AddTypeToAttributeMap(a.Type, a.AttributeName);
//agrego el tipo del item
this.AddTypeToAttributeItemMap(itemType, a.AttributeName);
this.AddAttributeToTypeItemMap(a.AttributeName, itemType);
//si el tipo del array es object[], los item son por ej int, detecta que no es inline, pero al serializaer los items va
//a detectar que cada item se tiene que serializar como attributo, pero no tiene elemento definido.....
//this.AddTypeToElementItemMap(a.Type.GetElementType(), a.AttributeName);
//this.AddElementToTypeItemMap(a.AttributeName, a.Type.GetElementType());
//el separador lo busco en la lista de attributos
this.AddAttribute(att);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlInlineArrayElementAttribute)
{
XmlInlineArrayElementAttribute a = att as XmlInlineArrayElementAttribute;
if (a.Type == null)
{
this.DefaultAttributeName = null;
this.DefaultElementName = a.ElementName;
if (!string.IsNullOrEmpty(a.ItemSeparator))
{
this.AddAttribute(a);
}
}
else
{
//agrego el tipo del item
this.AddTypeToElementItemMap(a.Type.GetElementType(), a.ElementName);
this.AddElementToTypeItemMap(a.ElementName, a.Type.GetElementType());
//agrego el tipo de el arrar..
this.AddElementToTypeMap(a.ElementName, a.Type);
this.AddTypeToElementMap(a.Type, a.ElementName);
//el separador lo busco en la lista de attributos
this.AddAttribute(att);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlArrayItemValueAttribute)
{
XmlArrayItemValueAttribute a = att as XmlArrayItemValueAttribute;
if (a.Type == null)
{
this.DefaulItemAttributeName = a.AttributeName;
this.DefaultItemElementName = a.ElementName;
}
else
{
this.AddTypeToElementItemMap(a.Type, a.ElementName);
this.AddElementToTypeItemMap(a.ElementName, a.Type);
if (TypeHelper.IsValueType(a.Type))
{
this.AddTypeToAttributeItemMap(a.Type, a.AttributeName);
this.AddAttributeToTypeItemMap(a.AttributeName, a.Type);
}
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlArrayItemAttribute)
{
XmlArrayItemAttribute a = att as XmlArrayItemAttribute;
if (a.Type == null)
{
this.DefaultItemElementName = a.ElementName;
}
else
{
this.AddTypeToElementItemMap(a.Type, a.ElementName);
this.AddElementToTypeItemMap(a.ElementName, a.Type);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlDictionaryKeyElementAttribute)
{
XmlDictionaryKeyElementAttribute a = att as XmlDictionaryKeyElementAttribute;
if (a.Type == null)
{
this.DefaultDictionaryKeyElementName = a.ElementName;
}
else
{
this.AddElementToTypeDictionaryKeyMap(a.ElementName, a.Type);
this.AddTypeToElementDictionaryKeyMap(a.Type, a.ElementName);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlDictionaryValueElementAttribute)
{
XmlDictionaryValueElementAttribute a = att as XmlDictionaryValueElementAttribute;
if (a.Type == null)
{
this.DefaultDictionaryValueElementName = a.ElementName;
}
else
{
this.AddElementToTypeDictionaryValueMap(a.ElementName, a.Type);
this.AddTypeToElementDictionaryValueMap(a.Type, a.ElementName);
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlDictionaryKeyAttributeAttribute)
{
XmlDictionaryKeyAttributeAttribute a = att as XmlDictionaryKeyAttributeAttribute;
if (a.Type == null)
{
Type declaringType = this.PropertyType;
Type keyType = typeof(object);
if (declaringType.IsGenericType)
{
Type[] genercisTypes = declaringType.GetGenericArguments();
keyType = genercisTypes[0];
}
if (TypeHelper.IsValueType(keyType))
{
this.DefaultDictionaryKeyAttributeName = a.AttributeName;
}
}
else
{
if (TypeHelper.IsValueType(a.Type))
{
this.AddAttributeToTypeDictionaryKeyMap(a.AttributeName, a.Type);
this.AddTypeToAttributeDictionaryKeyMap(a.Type, a.AttributeName);
}
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlDictionaryValueAttributeAttribute)
{
XmlDictionaryValueAttributeAttribute a = att as XmlDictionaryValueAttributeAttribute;
if (a.Type == null)
{
Type declaringType = this.PropertyType;
Type valueType = typeof(object);
if (declaringType.IsGenericType)
{
Type[] genercisTypes = declaringType.GetGenericArguments();
valueType = genercisTypes[0];
}
if (TypeHelper.IsValueType(valueType))
{
this.DefaultDictionaryValueAttributeName = a.AttributeName;
}
}
else
{
if (TypeHelper.IsValueType(a.Type))
{
this.AddAttributeToTypeDictionaryValueMap(a.AttributeName, a.Type);
this.AddTypeToAttributeDictionaryValueMap(a.Type, a.AttributeName);
}
if (!this.IncludeTypes.Contains(a.Type))
{
this.AddIncludeTypes(a.Type);
}
}
output = true;
}
else if (att is XmlDictionaryItemElementAttribute)
{
this.DictionaryItemElementName = ((XmlDictionaryItemElementAttribute)att).ElementName;
output = true;
}
else if (att is XmlElementAttribute)
{
XmlElementAttribute atElem = (XmlElementAttribute)att;
if (!string.IsNullOrEmpty(atElem.ElementName))
{
if (atElem.Type != null)
{
this.AddElementToTypeMap(atElem.ElementName, atElem.Type);
this.AddTypeToElementMap(atElem.Type, atElem.ElementName);
if (!this.IncludeTypes.Contains(atElem.Type))
{
this.AddIncludeTypes(atElem.Type);
}
}
else
{
this.DefaultElementName = atElem.ElementName;
}
}
else
{
this.DefaultElementName = this.PropertyName;
}
output = true;
}
else if (att is XmlAttributeAttribute)
{
XmlAttributeAttribute atElem = (XmlAttributeAttribute)att;
if (!string.IsNullOrEmpty(atElem.AttributeName))
{
if (atElem.Type != null)
{
if (TypeHelper.IsValueType(atElem.Type))
{
this.AddAttributeToTypeMap(atElem.AttributeName, atElem.Type);
this.AddTypeToAttributeMap(atElem.Type, atElem.AttributeName);
}
if (!this.IncludeTypes.Contains(atElem.Type))
{
this.AddIncludeTypes(atElem.Type);
}
}
else
{
if (TypeHelper.IsValueType(this.PropertyType))
{
this.DefaultAttributeName = atElem.AttributeName;
}
}
}
else
{
this.DefaultAttributeName = this.PropertyName;
}
output = true;
}
else
{
this.AddAttribute(att as Attribute);
}
return(output);
}
public void NamespaceDefault()
{
XmlElementAttribute attr = new XmlElementAttribute();
Assert.IsNull(attr.Namespace);
}
public void TypeDefault()
{
XmlElementAttribute attr = new XmlElementAttribute();
Assert.IsNull(attr.Type);
}
public void FormDefault()
{
XmlElementAttribute attr = new XmlElementAttribute();
Assert.AreEqual(XmlSchemaForm.None, attr.Form);
}
public void IsNullableDefault()
{
XmlElementAttribute attr = new XmlElementAttribute();
Assert.AreEqual(false, attr.IsNullable);
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter" /> stream to which the object is serialized.</param>
/// <exception cref="System.ArgumentNullException">writer</exception>
/// <exception cref="System.ArgumentException">
/// </exception>
public void WriteXml(XmlWriter writer)
{
writer.ThrowIfNull(nameof(writer));
Type keyType = typeof(TKey);
Type valueType = typeof(TValue);
// Check that each type we use is serializable
if (!keyType.IsSerializable)
{
throw new ArgumentException($"{keyType} is not serializable", keyType.ToString());
}
if (!valueType.IsSerializable)
{
throw new ArgumentException($"{valueType} is not serializable", valueType.ToString());
}
// Serialize each dictionary element as Xml
foreach (TKey key in Keys)
{
XmlRootAttribute rootAttribute =
valueType.GetCustomAttributes(typeof(XmlRootAttribute), false).Cast <XmlRootAttribute>().FirstOrDefault();
// Get the name specified in XmlRootAttribute or use the type name
string elementName = rootAttribute != null && !String.IsNullOrWhiteSpace(rootAttribute.ElementName)
? rootAttribute.ElementName
: TypeName;
// Write as XmlElement
writer.WriteStartElement(elementName);
// Do we have properties ?
if (valueType.GetProperties().Length == 0)
{
string attributeName = TypeName;
// Write the value as XmlAttribute
writer.WriteAttributeString(attributeName, this[key].ToString());
}
else
{
// Note: Best practice is to serialize properties instead of fields;
// however if you have to serialize fields use the 'GetFields()' method
// and adjust the code accordingly using the 'NonSerializedAttribute'
// Write each property value as XmlAttribute excluding those that have the 'XmlIgnoreAttribute'
foreach (PropertyInfo property in valueType.GetProperties().Where(
property => !Attribute.IsDefined(property, typeof(XmlIgnoreAttribute))))
{
Attribute attribute = property.GetCustomAttributes(false).Where(
x => x is XmlElementAttribute || x is XmlAttributeAttribute).Cast <Attribute>().FirstOrDefault();
XmlElementAttribute xmlElement = attribute as XmlElementAttribute;
XmlAttributeAttribute xmlAttribute = attribute as XmlAttributeAttribute;
// Get the name specified in XmlElement/XmlAttribute or use the property name
string attributeName;
if (xmlElement != null && !String.IsNullOrWhiteSpace(xmlElement.ElementName))
{
attributeName = xmlElement.ElementName;
}
else if (xmlAttribute != null && !String.IsNullOrWhiteSpace(xmlAttribute.AttributeName))
{
attributeName = xmlAttribute.AttributeName;
}
else
{
attributeName = property.Name;
}
object propertyValue = property.GetValue(this[key], null);
// Special condition for Boolean type (because "Boolean.ToString()" returns "True"/"False")
string propertyValueString = propertyValue is Boolean
? XmlConvert.ToString((bool)propertyValue)
: propertyValue.ToString();
writer.WriteAttributeString(attributeName, propertyValueString);
}
}
// Write the key as XmlText
writer.WriteValue(key.ToString());
writer.WriteEndElement();
}
}
/// <summary>
/// Fills the struct with information about the field
/// </summary>
/// <param name="info">Struct to fill</param>
/// <param name="field">Field descrived by the struct</param>
private static void _FillInfo(ref SFieldInfo info, MemberInfo field)
{
XmlAttributeAttribute attribute = field.GetAttribute <XmlAttributeAttribute>();
if (attribute != null)
{
info.IsAttribute = true;
info.Name = attribute.AttributeName;
}
else
{
XmlElementAttribute element = field.GetAttribute <XmlElementAttribute>();
if (element != null)
{
info.Name = element.ElementName;
}
else
{
XmlArrayAttribute array = field.GetAttribute <XmlArrayAttribute>();
if (array != null)
{
Debug.Assert(info.Type.IsList() || info.Type.IsArray, "Only lists and arrays can have the array attribute");
Debug.Assert(!info.IsAttribute, "Lists cannot be attributes");
info.Name = array.ElementName;
info.IsList = true;
}
}
}
if (string.IsNullOrEmpty(info.Name))
{
info.Name = field.Name;
}
XmlAltNameAttribute altName = field.GetAttribute <XmlAltNameAttribute>();
if (altName != null)
{
info.AltName = altName.AltName;
}
if (info.Type.IsGenericType)
{
info.SubType = info.Type.GetGenericArguments().Last();
}
else if (info.Type.IsArray)
{
info.SubType = info.Type.GetElementType();
}
if (info.Type.IsList() || info.Type.IsArray)
{
if (!info.IsList)
{
Debug.Assert(!field.HasAttribute <XmlArrayAttribute>(), "A field cannot have an XmlElement- and XmlArray-Attribute");
if (info.Type.IsArray && info.SubType == typeof(byte))
{
info.IsByteArray = true;
}
else
{
info.IsEmbeddedList = true;
}
}
else
{
XmlArrayItemAttribute arrayItem = field.GetAttribute <XmlArrayItemAttribute>();
if (arrayItem != null && !string.IsNullOrEmpty(arrayItem.ElementName))
{
info.ArrayItemName = arrayItem.ElementName;
}
}
}
else if (info.Type.IsNullable())
{
info.IsNullable = true;
}
else if (info.Type.IsDictionary())
{
Debug.Assert(info.Type.GetGenericArguments()[0] == typeof(string), "Keys of dictionaries must be strings");
info.IsDictionary = true;
}
if (field.HasAttribute <XmlNormalizedAttribute>())
{
Debug.Assert(info.Type == typeof(float) || (info.IsNullable && info.SubType == typeof(float)), "Only floats can be normalized");
}
info.Ranged = field.GetAttribute <XmlRangedAttribute>();
Type tmpType = info.IsNullable ? info.SubType : info.Type;
Debug.Assert(info.Ranged == null || tmpType == typeof(int) || tmpType == typeof(float) || tmpType == typeof(double),
"Only ints,floats and double can be ranged");
DefaultValueAttribute defAttr = field.GetAttribute <DefaultValueAttribute>();
if (defAttr != null)
{
Debug.Assert(!info.Type.IsList(), "Lists cannot have a default value");
info.HasDefaultValue = true;
info.DefaultValue = defAttr.Value;
}
else if (info.IsNullable)
{
info.HasDefaultValue = true;
info.DefaultValue = null;
}
}
public static PloppableRICODefinition DeserializeRICODefinition(string packageName, Stream ricoDefStream, bool insanityOK)
{
// Note here we're using insanityOK as a local settings flag.
string localOrAuthor = insanityOK ? "local" : "author";
try
{
XmlAttributes attrs = new XmlAttributes();
XmlElementAttribute attr = new XmlElementAttribute();
attr.ElementName = "RICOBuilding";
attr.Type = typeof(RICOBuilding);
XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
attrOverrides.Add(typeof(RICOBuilding), "Building", attrs);
var streamReader = new System.IO.StreamReader(ricoDefStream);
var xmlSerializer = new XmlSerializer(typeof(PloppableRICODefinition), attrOverrides);
var result = xmlSerializer.Deserialize(streamReader) as PloppableRICODefinition;
StringBuilder errorList;
if (result.Buildings.Count == 0)
{
Debugging.Message("no parseable buildings in " + localOrAuthor + " XML settings file");
}
else
{
foreach (var building in result.Buildings)
{
// Check for fatal errors in each building.
errorList = building.fatalErrors;
if (errorList.Length == 0)
{
// No fatal errors; check for non-fatal errors.
errorList = building.nonFatalErrors;
if (errorList.Length != 0)
{
// Errors found - how we report them depends on whether its local or author settings (we're assuming mod settings are fine).
if (insanityOK && building.ricoEnabled)
{
// Errors in local settings need to be reported direct to user, except for buildings that aren't activated in RICO.
Debugging.ErrorBuffer.Append(errorList.ToString());
Debugging.Message("non-fatal errors for building '" + building.name + "' in local settings");
}
else if (Settings.debugLogging)
{
// Errors in other settings should be logged if verbose logging is enabled, but otherwise continue.
errorList.Insert(0, "found the following non-fatal errors for building '" + building.name + "' in author settings:\r\n");
Debugging.Message(errorList.ToString());
}
}
// No fatal errors; building is good (enough).
building.parent = result;
}
else
{
// Fatal errors! Need to be reported direct to user and the building ignored.
Debugging.ErrorBuffer.Append(errorList.ToString());
Debugging.Message("fatal errors for building '" + building.name + "' in " + localOrAuthor + " settings");
}
}
}
streamReader.Close();
result.clean();
return(result);
}
catch (Exception e)
{
Debugging.ErrorBuffer.AppendLine(String.Format("Unexpected Exception while deserializing " + localOrAuthor + " RICO file {0} ({1} [{2}])", packageName, e.Message, e.InnerException != null ? e.InnerException.Message : ""));
return(null);
}
}
/// <summary>
/// Loads and parses the given RICO file.
/// </summary>
/// <param name="ricoDefPath">Definition file path</param>
/// <param name="isLocal">True if this is a local settings file, false for author settings file</param>
/// <returns>Parsed Ploppable RICO definition file</returns>
public static PloppableRICODefinition ParseRICODefinition(string ricoDefPath, bool isLocal = false)
{
// Local settings flag.
string localOrAuthor = isLocal ? "local" : "author";
try
{
// Open file.
using (StreamReader reader = new StreamReader(ricoDefPath))
{
// Create new XML (de)serializer
XmlAttributes attrs = new XmlAttributes();
XmlElementAttribute attr = new XmlElementAttribute
{
ElementName = "RICOBuilding",
Type = typeof(RICOBuilding)
};
XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
attrOverrides.Add(typeof(RICOBuilding), "Building", attrs);
// Read XML.
XmlSerializer xmlSerializer = new XmlSerializer(typeof(PloppableRICODefinition), attrOverrides);
PloppableRICODefinition result = xmlSerializer.Deserialize(reader) as PloppableRICODefinition;
StringBuilder errorList;
if (result.Buildings.Count == 0)
{
Logging.Message("no parseable buildings in ", localOrAuthor, " XML settings file at ", ricoDefPath);
}
else
{
foreach (RICOBuilding building in result.Buildings)
{
// Check for fatal errors in each building.
errorList = building.FatalErrors;
if (errorList.Length == 0)
{
// No fatal errors; check for non-fatal errors.
errorList = building.NonFatalErrors;
if (errorList.Length != 0)
{
if (isLocal && building.ricoEnabled)
{
// Errors in local settings need to be reported, except for buildings that aren't activated in RICO (e.g. for when the user has de-activated a RICO builidng with issues).
Logging.Error("non-fatal errors for building '", building.Name, "' in local settings:\r\n", errorList.ToString());
}
else
{
// Errors in other settings should be logged if verbose logging is enabled, but otherwise continue.
Logging.Message("non-fatal errors for building '", building.Name, "' in author settings:\r\n", errorList.ToString());
}
}
}
else
{
// Fatal errors! Need to be reported direct to user and the building ignored.
Logging.Error("fatal errors for building '", building.Name, "' in ", localOrAuthor, " settings:\r\n", errorList.ToString());
}
}
}
reader.Close();
return(result);
}
}
catch (Exception e)
{
Logging.LogException(e, "Unexpected Exception while deserializing ", localOrAuthor, " RICO file at ", ricoDefPath);
return(null);
}
}
internal static void LoadXmlFormatExtensions(Type[] extensionTypes, XmlAttributeOverrides overrides, XmlSerializerNamespaces namespaces)
{
Hashtable table = new Hashtable();
table.Add(typeof(ServiceDescription), new XmlAttributes());
table.Add(typeof(Import), new XmlAttributes());
table.Add(typeof(Port), new XmlAttributes());
table.Add(typeof(Service), new XmlAttributes());
table.Add(typeof(FaultBinding), new XmlAttributes());
table.Add(typeof(InputBinding), new XmlAttributes());
table.Add(typeof(OutputBinding), new XmlAttributes());
table.Add(typeof(OperationBinding), new XmlAttributes());
table.Add(typeof(Binding), new XmlAttributes());
table.Add(typeof(OperationFault), new XmlAttributes());
table.Add(typeof(OperationInput), new XmlAttributes());
table.Add(typeof(OperationOutput), new XmlAttributes());
table.Add(typeof(Operation), new XmlAttributes());
table.Add(typeof(PortType), new XmlAttributes());
table.Add(typeof(Message), new XmlAttributes());
table.Add(typeof(MessagePart), new XmlAttributes());
table.Add(typeof(Types), new XmlAttributes());
Hashtable extensions = new Hashtable();
foreach (Type extensionType in extensionTypes)
{
if (extensions[extensionType] != null)
{
continue;
}
extensions.Add(extensionType, extensionType);
object[] attrs = new List <object>(extensionType.GetTypeInfo().GetCustomAttributes(typeof(XmlFormatExtensionAttribute), false)).ToArray();
if (attrs.Length == 0)
{
throw new ArgumentException(string.Format(ResWebServices.RequiredXmlFormatExtensionAttributeIsMissing1, extensionType.FullName), "extensionTypes");
}
XmlFormatExtensionAttribute extensionAttr = (XmlFormatExtensionAttribute)attrs[0];
foreach (Type extensionPointType in extensionAttr.ExtensionPoints)
{
XmlAttributes xmlAttrs = (XmlAttributes)table[extensionPointType];
if (xmlAttrs == null)
{
xmlAttrs = new XmlAttributes();
table.Add(extensionPointType, xmlAttrs);
}
XmlElementAttribute xmlAttr = new XmlElementAttribute(extensionAttr.ElementName, extensionType);
xmlAttr.Namespace = extensionAttr.Namespace;
xmlAttrs.XmlElements.Add(xmlAttr);
}
attrs = new List <object>(extensionType.GetTypeInfo().GetCustomAttributes(typeof(XmlFormatExtensionPrefixAttribute), false)).ToArray();
string[] prefixes = new string[attrs.Length];
Hashtable nsDefs = new Hashtable();
for (int i = 0; i < attrs.Length; i++)
{
XmlFormatExtensionPrefixAttribute prefixAttr = (XmlFormatExtensionPrefixAttribute)attrs[i];
prefixes[i] = prefixAttr.Prefix;
nsDefs.Add(prefixAttr.Prefix, prefixAttr.Namespace);
}
Array.Sort(prefixes);
for (int i = 0; i < prefixes.Length; i++)
{
namespaces.Add(prefixes[i], (string)nsDefs[prefixes[i]]);
}
}
foreach (Type extensionPointType in table.Keys)
{
XmlFormatExtensionPointAttribute attr = GetExtensionPointAttribute(extensionPointType);
XmlAttributes xmlAttrs = (XmlAttributes)table[extensionPointType];
if (attr.AllowElements)
{
xmlAttrs.XmlAnyElements.Add(new XmlAnyElementAttribute());
}
overrides.Add(extensionPointType, attr.MemberName, xmlAttrs);
}
}
public void Remove(XmlElementAttribute attribute)
{
}
private static void ImportPropertyInfo(StructMapping mapping, PropertyInfo prop)
{
Type type = prop.PropertyType;
bool flag = false;
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
flag = true;
type = type.GetGenericArguments()[0];
}
bool flag2 = false;
XmlAttributes xmlAttributes = new XmlAttributes();
object[] array = type.GetCustomAttributes(inherit: true);
object[] customAttributes = prop.GetCustomAttributes(inherit: true);
bool flag3 = false;
int num = array.Length;
Array.Resize(ref array, num + customAttributes.Length);
customAttributes.CopyTo(array, num);
object[] array2 = array;
foreach (object obj in array2)
{
Type type2 = obj.GetType();
if (type2 == typeof(XmlIgnoreAttribute))
{
return;
}
if (typeof(DefaultValueAttribute).IsAssignableFrom(type2))
{
xmlAttributes.XmlDefaultValue = ((DefaultValueAttribute)obj).Value;
}
else if (typeof(XmlElementAttribute).IsAssignableFrom(type2))
{
XmlElementAttribute xmlElementAttribute = (XmlElementAttribute)obj;
xmlAttributes.XmlElements.Add(xmlElementAttribute);
if (xmlElementAttribute.Type != null)
{
if (string.IsNullOrEmpty(xmlElementAttribute.ElementName))
{
type = xmlElementAttribute.Type;
}
else
{
flag2 = true;
}
}
}
else if (type2 == typeof(XmlArrayItemAttribute))
{
XmlArrayItemAttribute xmlArrayItemAttribute = (XmlArrayItemAttribute)obj;
int j;
for (j = 0; j < xmlAttributes.XmlArrayItems.Count && xmlAttributes.XmlArrayItems[j].NestingLevel <= xmlArrayItemAttribute.NestingLevel; j++)
{
}
xmlAttributes.XmlArrayItems.Insert(j, xmlArrayItemAttribute);
}
else if (typeof(XmlAttributeAttribute).IsAssignableFrom(type2))
{
xmlAttributes.XmlAttribute = (XmlAttributeAttribute)obj;
}
else if (type2 == typeof(ValidValuesAttribute) || type2 == typeof(ValidEnumValuesAttribute))
{
flag3 = true;
}
}
string tagName = prop.Name;
string ns = string.Empty;
if (!flag2)
{
GetMemberName(xmlAttributes, ref tagName, ref ns);
}
if (mapping.GetElement(tagName, ns) != null || mapping.GetAttribute(tagName, ns) != null)
{
return;
}
PropertyMapping propertyMapping = new PropertyMapping(type, tagName, ns, prop);
propertyMapping.XmlAttributes = xmlAttributes;
mapping.Members.Add(propertyMapping);
if (xmlAttributes.XmlAttribute != null)
{
if (xmlAttributes.XmlAttribute is XmlChildAttributeAttribute)
{
mapping.AddChildAttribute(propertyMapping);
}
else
{
mapping.Attributes[tagName, ns] = propertyMapping;
}
}
else
{
mapping.Elements[tagName, ns] = propertyMapping;
if (flag2)
{
mapping.AddUseTypeInfo(tagName, ns);
}
}
Type declaringType = prop.DeclaringType;
if (!declaringType.IsSubclassOf(typeof(ReportObject)))
{
return;
}
Type type3 = declaringType.Assembly.GetType(declaringType.FullName + "+Definition+Properties", throwOnError: false);
FieldInfo field;
if (type3 != null && type3.IsEnum && (field = type3.GetField(prop.Name)) != null)
{
propertyMapping.Index = (int)field.GetRawConstantValue();
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Object;
if (flag)
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Object;
}
else if (type.IsSubclassOf(typeof(IContainedObject)))
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.ContainedObject;
}
else if (type == typeof(bool))
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Boolean;
}
else if (type == typeof(int))
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Integer;
}
else if (type == typeof(ReportSize))
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Size;
}
else if (type.IsEnum)
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.Enum;
}
else if (type.IsValueType)
{
propertyMapping.TypeCode = PropertyMapping.PropertyTypeCode.ValueType;
}
if (flag3)
{
type3 = declaringType.Assembly.GetType(declaringType.FullName + "+Definition", throwOnError: false);
propertyMapping.Definition = (IPropertyDefinition)type3.InvokeMember("GetProperty", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod, null, null, new object[1]
{
propertyMapping.Index
}, CultureInfo.InvariantCulture);
}
}
}
/// <summary>
/// 用序列化方法加载reference的成员.
/// </summary>
/// <param name="reference">引用.</param>
/// <param name="fileName">xml文件名.</param>
/// <param name="option">操作.</param>
/// <param name="condition">判断条件,用以忽略不必要的属性.</param>
internal static void XSerialize(object reference, string fileName, XSerializeOption option, Predicate <string> condition = null)
{
if (option == XSerializeOption.Serialize)
{
string comment = "设置类1.0.4.0版本,基于USettingsObject.";
XElement xElement = new XElement(reference.GetType().ToString());
foreach (var propertyInfo in reference.GetType().GetProperties())
{
if (condition == null || condition(propertyInfo.Name))
{
XElement element = USettings.ToXElement(new KeyValuePair <PropertyInfo, object>(propertyInfo, reference));
if (element != null)
{
xElement.Add(element);
}
}
}
XDocument xDocument = new XDocument(new XComment(comment), xElement);
xDocument.Save(fileName);
}
else
{
if (File.Exists(fileName))
{
XDocument xDocument;
try
{
xDocument = XDocument.Load(fileName);
}
catch (Exception)//>>说明文件被破坏
{
File.Delete(fileName);
return;
}
foreach (var propertyInfo in reference.GetType().GetProperties())
{
if (propertyInfo.GetCustomAttribute(typeof(XmlIgnoreAttribute)) == null && propertyInfo.CanWrite && propertyInfo.CanRead)
{
string elementName = propertyInfo.Name;
XmlElementAttribute attribute = (XmlElementAttribute)propertyInfo.GetCustomAttribute(typeof(XmlElementAttribute));
if (attribute != null)
{
elementName = attribute.ElementName;
}
XElement element = xDocument.Root.Element(elementName);
if (element != null)
{
if (condition == null || condition(elementName))
{
object o = USettings.ToObject(element, propertyInfo.PropertyType);
propertyInfo.SetValue(reference, o);
}
}
}
}
}
}
}
// Writes everything in a xml file
public void WriteXml(XmlWriter writer)
{
AbstractData ent;
// Iterated through the properties
foreach (PropertyInfo propInfo in GetType().GetProperties())
{
// We only care for subclasses of AbstractData
if (!propInfo.PropertyType.IsSubclassOf(typeof(AbstractData)))
{
continue;
}
// We only write valid data and if it is invalid and mandory, then
// we cancel the write process.
ent = (AbstractData)propInfo.GetValue(this);
if (!ent.IsValid)
{
if (ent.IsMandory)
{
break;
}
continue;
}
// We write only necessary data, i.e. if it is valid, non-mandory and
// empty, then we do not write it.
if (!ent.WriteNecessary)
{
continue;
}
// Some information (as the value name in the .xml-file) can also be
// saved in the XmlElementAttribute
XmlElementAttribute res
= (XmlElementAttribute)propInfo.GetCustomAttribute(typeof(XmlElementAttribute));
if (res != null)
{
if ((res.ElementName != null) && (res.ElementName != ""))
{
if ((res.Namespace != null) && (res.Namespace != ""))
{
writer.WriteStartElement(res.ElementName, res.Namespace);
}
else
{
writer.WriteStartElement(res.ElementName);
}
}
else
{
writer.WriteStartElement(propInfo.Name);
}
}
else
{
writer.WriteStartElement(propInfo.Name);
}
ent.WriteXml(writer);
writer.WriteEndElement();
}
}
private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
{
if (recordType == null)
{
return;
}
if (!recordType.IsDynamicType())
{
IsComplexXPathUsed = false;
Type pt = null;
if (optIn) //ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType<ChoXmlNodeRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
var fa = pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().FirstOrDefault();
bool optIn1 = fa == null || fa.UseXmlSerialization ? optIn : ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()).Any();
if (false) //optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1);
}
else if (pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any())
{
bool useCache = true;
string xpath = null;
ChoXmlNodeRecordFieldAttribute attr = ChoTypeDescriptor.GetPropetyAttribute <ChoXmlNodeRecordFieldAttribute>(pd);
if (attr.XPath.IsNullOrEmpty())
{
if (!attr.FieldName.IsNullOrWhiteSpace())
{
attr.XPath = $"/{attr.FieldName}|/@{attr.FieldName}";
}
else
{
attr.XPath = xpath = $"/{pd.Name}|/@{pd.Name}";
}
IsComplexXPathUsed = true;
}
else
{
useCache = false;
}
var obj = new ChoXmlRecordFieldConfiguration(pd.Name, attr, pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
obj.UseCache = useCache;
if (obj.XPath.IsNullOrWhiteSpace())
{
if (!obj.FieldName.IsNullOrWhiteSpace())
{
obj.XPath = $"/{obj.FieldName}|/@{obj.FieldName}";
}
else
{
obj.XPath = $"/{obj.Name}|/@{obj.Name}";
}
}
obj.FieldType = pd.PropertyType.GetUnderlyingType();
if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
XmlRecordFieldConfigurations.Add(obj);
}
}
}
}
else
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
XmlIgnoreAttribute xiAttr = pd.Attributes.OfType <XmlIgnoreAttribute>().FirstOrDefault();
if (xiAttr != null)
{
continue;
}
pt = pd.PropertyType.GetUnderlyingType();
if (false) //pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
}
else
{
var obj = new ChoXmlRecordFieldConfiguration(pd.Name, $"/{pd.Name}|/@{pd.Name}");
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
XmlElementAttribute xAttr = pd.Attributes.OfType <XmlElementAttribute>().FirstOrDefault();
if (xAttr != null && !xAttr.ElementName.IsNullOrWhiteSpace())
{
obj.FieldName = xAttr.ElementName;
}
else
{
XmlAttributeAttribute xaAttr = pd.Attributes.OfType <XmlAttributeAttribute>().FirstOrDefault();
if (xAttr != null && !xaAttr.AttributeName.IsNullOrWhiteSpace())
{
obj.FieldName = xaAttr.AttributeName;
}
else
{
DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
{
obj.FieldName = dnAttr.DisplayName.Trim();
}
else
{
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
}
}
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
XmlRecordFieldConfigurations.Add(obj);
}
}
}
}
}
}
static internal XmlReflectionMember GetXmlReflectionMember(XmlName memberName, XmlName elementName, string ns, Type type, MemberInfo additionalAttributesProvider, bool isMultiple, bool isWrapped)
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = (memberName ?? elementName).DecodedName;
member.MemberType = type;
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
if (isMultiple)
{
member.MemberType = member.MemberType.MakeArrayType();
}
if (additionalAttributesProvider != null)
{
member.XmlAttributes = XmlAttributesHelper.CreateXmlAttributes(additionalAttributesProvider);
}
if (member.XmlAttributes == null)
{
member.XmlAttributes = new XmlAttributes();
}
else
{
Type invalidAttributeType = null;
if (member.XmlAttributes.XmlAttribute != null)
{
invalidAttributeType = typeof(XmlAttributeAttribute);
}
else if (member.XmlAttributes.XmlAnyAttribute != null && !isWrapped)
{
invalidAttributeType = typeof(XmlAnyAttributeAttribute);
}
else if (member.XmlAttributes.XmlChoiceIdentifier != null)
{
invalidAttributeType = typeof(XmlChoiceIdentifierAttribute);
}
else if (member.XmlAttributes.XmlIgnore)
{
invalidAttributeType = typeof(XmlIgnoreAttribute);
}
else if (member.XmlAttributes.Xmlns)
{
invalidAttributeType = typeof(XmlNamespaceDeclarationsAttribute);
}
else if (member.XmlAttributes.XmlText != null)
{
invalidAttributeType = typeof(XmlTextAttribute);
}
else if (member.XmlAttributes.XmlEnum != null)
{
invalidAttributeType = typeof(XmlEnumAttribute);
}
if (invalidAttributeType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(isWrapped ? SR.SFxInvalidXmlAttributeInWrapped : SR.SFxInvalidXmlAttributeInBare, invalidAttributeType, elementName.DecodedName)));
}
if (member.XmlAttributes.XmlArray != null && isMultiple)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxXmlArrayNotAllowedForMultiple, elementName.DecodedName, ns)));
}
}
bool isArray = member.MemberType.IsArray;
if ((isArray && !isMultiple && member.MemberType != typeof(byte[])) ||
(!isArray && typeof(IEnumerable).IsAssignableFrom(member.MemberType) && member.MemberType != typeof(string) && !typeof(XmlNode).IsAssignableFrom(member.MemberType) && !typeof(IXmlSerializable).IsAssignableFrom(member.MemberType)))
{
if (member.XmlAttributes.XmlArray != null)
{
if (member.XmlAttributes.XmlArray.ElementName == String.Empty)
{
member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName;
}
if (member.XmlAttributes.XmlArray.Namespace == null)
{
member.XmlAttributes.XmlArray.Namespace = ns;
}
}
else if (HasNoXmlParameterAttributes(member.XmlAttributes))
{
member.XmlAttributes.XmlArray = new XmlArrayAttribute();
member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName;
member.XmlAttributes.XmlArray.Namespace = ns;
}
}
else
{
if (member.XmlAttributes.XmlElements == null || member.XmlAttributes.XmlElements.Count == 0)
{
if (HasNoXmlParameterAttributes(member.XmlAttributes))
{
XmlElementAttribute elementAttribute = new XmlElementAttribute();
elementAttribute.ElementName = elementName.DecodedName;
elementAttribute.Namespace = ns;
member.XmlAttributes.XmlElements.Add(elementAttribute);
}
}
else
{
foreach (XmlElementAttribute elementAttribute in member.XmlAttributes.XmlElements)
{
if (elementAttribute.ElementName == String.Empty)
{
elementAttribute.ElementName = elementName.DecodedName;
}
if (elementAttribute.Namespace == null)
{
elementAttribute.Namespace = ns;
}
}
}
}
return(member);
}
internal static void LoadXmlFormatExtensions(Type[] extensionTypes, XmlAttributeOverrides overrides, XmlSerializerNamespaces namespaces)
{
Hashtable hashtable = new Hashtable();
hashtable.Add(typeof(ServiceDescription), new XmlAttributes());
hashtable.Add(typeof(Import), new XmlAttributes());
hashtable.Add(typeof(Port), new XmlAttributes());
hashtable.Add(typeof(Service), new XmlAttributes());
hashtable.Add(typeof(FaultBinding), new XmlAttributes());
hashtable.Add(typeof(InputBinding), new XmlAttributes());
hashtable.Add(typeof(OutputBinding), new XmlAttributes());
hashtable.Add(typeof(OperationBinding), new XmlAttributes());
hashtable.Add(typeof(Binding), new XmlAttributes());
hashtable.Add(typeof(OperationFault), new XmlAttributes());
hashtable.Add(typeof(OperationInput), new XmlAttributes());
hashtable.Add(typeof(OperationOutput), new XmlAttributes());
hashtable.Add(typeof(Operation), new XmlAttributes());
hashtable.Add(typeof(PortType), new XmlAttributes());
hashtable.Add(typeof(Message), new XmlAttributes());
hashtable.Add(typeof(MessagePart), new XmlAttributes());
hashtable.Add(typeof(Types), new XmlAttributes());
Hashtable hashtable2 = new Hashtable();
foreach (Type type in extensionTypes)
{
if (hashtable2[type] == null)
{
hashtable2.Add(type, type);
object[] customAttributes = type.GetCustomAttributes(typeof(XmlFormatExtensionAttribute), false);
if (customAttributes.Length == 0)
{
throw new ArgumentException(Res.GetString("RequiredXmlFormatExtensionAttributeIsMissing1", new object[] { type.FullName }), "extensionTypes");
}
XmlFormatExtensionAttribute attribute = (XmlFormatExtensionAttribute)customAttributes[0];
foreach (Type type2 in attribute.ExtensionPoints)
{
XmlAttributes attributes = (XmlAttributes)hashtable[type2];
if (attributes == null)
{
attributes = new XmlAttributes();
hashtable.Add(type2, attributes);
}
XmlElementAttribute attribute2 = new XmlElementAttribute(attribute.ElementName, type)
{
Namespace = attribute.Namespace
};
attributes.XmlElements.Add(attribute2);
}
customAttributes = type.GetCustomAttributes(typeof(XmlFormatExtensionPrefixAttribute), false);
string[] array = new string[customAttributes.Length];
Hashtable hashtable3 = new Hashtable();
for (int i = 0; i < customAttributes.Length; i++)
{
XmlFormatExtensionPrefixAttribute attribute3 = (XmlFormatExtensionPrefixAttribute)customAttributes[i];
array[i] = attribute3.Prefix;
hashtable3.Add(attribute3.Prefix, attribute3.Namespace);
}
Array.Sort(array, System.InvariantComparer.Default);
for (int j = 0; j < array.Length; j++)
{
namespaces.Add(array[j], (string)hashtable3[array[j]]);
}
}
}
foreach (Type type3 in hashtable.Keys)
{
XmlFormatExtensionPointAttribute extensionPointAttribute = GetExtensionPointAttribute(type3);
XmlAttributes attributes2 = (XmlAttributes)hashtable[type3];
if (extensionPointAttribute.AllowElements)
{
attributes2.XmlAnyElements.Add(new XmlAnyElementAttribute());
}
overrides.Add(type3, extensionPointAttribute.MemberName, attributes2);
}
}
/// <summary>
/// Adds specified instance of XmlElementAttribute to current type or member
/// </summary>
public OverrideXml Attr(XmlElementAttribute attribute)
{
Open();
_attributes.XmlElements.Add(attribute);
return(this);
}
public int Add(XmlElementAttribute attribute);
public void Insert(int index, XmlElementAttribute attribute)
{
}
public void CopyTo(XmlElementAttribute[] array, int index);
public int IndexOf(XmlElementAttribute attribute)
{
}
public void Insert(int index, XmlElementAttribute attribute);
public bool Contains(XmlElementAttribute attribute)
{
}
public override string ToString ()
{
string result = string.Empty;
using (MemoryStream stream = new MemoryStream ()) {
using (StreamReader sr = new StreamReader (stream)) {
XmlTextWriter writer = null;
try {
writer = new XmlTextWriter (stream, System.Text.Encoding.UTF8);
XmlAttributes attrs = new XmlAttributes ();
XmlElementAttribute attr = new XmlElementAttribute ();
attr.ElementName = "UnknownItemSerializer";
attr.Type = typeof (UnknownItemSerializer);
attrs.XmlElements.Add (attr);
XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides ();
attrOverrides.Add (typeof (TestClass), "Item", attrs);
XmlSerializer serializer = new XmlSerializer (this.GetType (), attrOverrides);
serializer.Serialize (writer, this);
stream.Position = 0;
result = sr.ReadToEnd ();
} finally {
if (writer != null)
writer.Close ();
}
}
}
return result;
}
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs)
{
try {
string methodId = methodInfo.GetKey();
SoapReflectedMethod soapMethod = new SoapReflectedMethod();
MethodAttribute methodAttribute = new MethodAttribute();
object serviceAttr = GetSoapServiceAttribute(methodInfo.DeclaringType);
bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(serviceAttr);
object methodAttr = GetSoapMethodAttribute(methodInfo);
if (methodAttr == null)
{
if (client)
{
return(null); // method attribute required on the client
}
if (serviceAttr is SoapRpcServiceAttribute)
{
SoapRpcMethodAttribute method = new SoapRpcMethodAttribute();
method.Use = ((SoapRpcServiceAttribute)serviceAttr).Use;
methodAttr = method;
}
else if (serviceAttr is SoapDocumentServiceAttribute)
{
SoapDocumentMethodAttribute method = new SoapDocumentMethodAttribute();
method.Use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
methodAttr = method;
}
else
{
methodAttr = new SoapDocumentMethodAttribute();
}
}
if (methodAttr is SoapRpcMethodAttribute)
{
SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr;
soapMethod.rpc = true;
soapMethod.use = attr.Use;
soapMethod.oneWay = attr.OneWay;
methodAttribute.action = attr.Action;
methodAttribute.binding = attr.Binding;
methodAttribute.requestName = attr.RequestElementName;
methodAttribute.requestNs = attr.RequestNamespace;
methodAttribute.responseName = attr.ResponseElementName;
methodAttribute.responseNs = attr.ResponseNamespace;
}
else
{
SoapDocumentMethodAttribute attr = (SoapDocumentMethodAttribute)methodAttr;
soapMethod.rpc = false;
soapMethod.use = attr.Use;
soapMethod.paramStyle = attr.ParameterStyle;
soapMethod.oneWay = attr.OneWay;
methodAttribute.action = attr.Action;
methodAttribute.binding = attr.Binding;
methodAttribute.requestName = attr.RequestElementName;
methodAttribute.requestNs = attr.RequestNamespace;
methodAttribute.responseName = attr.ResponseElementName;
methodAttribute.responseNs = attr.ResponseNamespace;
if (soapMethod.use == SoapBindingUse.Default)
{
if (serviceAttr is SoapDocumentServiceAttribute)
{
soapMethod.use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
}
if (soapMethod.use == SoapBindingUse.Default)
{
soapMethod.use = SoapBindingUse.Literal;
}
}
if (soapMethod.paramStyle == SoapParameterStyle.Default)
{
if (serviceAttr is SoapDocumentServiceAttribute)
{
soapMethod.paramStyle = ((SoapDocumentServiceAttribute)serviceAttr).ParameterStyle;
}
if (soapMethod.paramStyle == SoapParameterStyle.Default)
{
soapMethod.paramStyle = SoapParameterStyle.Wrapped;
}
}
}
if (methodAttribute.binding.Length > 0)
{
if (client)
{
throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingPlacement, methodAttr.GetType().Name));
}
soapMethod.binding = WebServiceBindingReflector.GetAttribute(methodInfo, methodAttribute.binding);
}
WebMethodAttribute webMethodAttribute = methodInfo.MethodAttribute;
//
soapMethod.name = webMethodAttribute.MessageName;
if (soapMethod.name.Length == 0)
{
soapMethod.name = methodInfo.Name;
}
string requestElementName;
if (soapMethod.rpc)
{
// in the case when we interop with non .net we might need to chnage the method name.
requestElementName = methodAttribute.requestName.Length == 0 || !client ? methodInfo.Name : methodAttribute.requestName;
}
else
{
requestElementName = methodAttribute.requestName.Length == 0 ? soapMethod.name : methodAttribute.requestName;
}
string requestNamespace = methodAttribute.requestNs;
if (requestNamespace == null)
{
if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
{
requestNamespace = soapMethod.binding.Namespace;
}
else
{
requestNamespace = defaultNs;
}
}
string responseElementName;
if (soapMethod.rpc && soapMethod.use != SoapBindingUse.Encoded)
{
// NOTE: this rule should apply equally to rpc/lit and rpc/enc, but to reduce risk, i'm only applying it to rpc/lit
responseElementName = methodInfo.Name + "Response";
}
else
{
responseElementName = methodAttribute.responseName.Length == 0 ? soapMethod.name + "Response" : methodAttribute.responseName;
}
string responseNamespace = methodAttribute.responseNs;
if (responseNamespace == null)
{
if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
{
responseNamespace = soapMethod.binding.Namespace;
}
else
{
responseNamespace = defaultNs;
}
}
SoapParameterInfo[] inParameters = ReflectParameters(methodInfo.InParameters, requestNamespace);
SoapParameterInfo[] outParameters = ReflectParameters(methodInfo.OutParameters, responseNamespace);
soapMethod.action = methodAttribute.action;
if (soapMethod.action == null)
{
soapMethod.action = GetDefaultAction(defaultNs, methodInfo);
}
soapMethod.methodInfo = methodInfo;
if (soapMethod.oneWay)
{
if (outParameters.Length > 0)
{
throw new ArgumentException(Res.GetString(Res.WebOneWayOutParameters), "methodInfo");
}
if (methodInfo.ReturnType != typeof(void))
{
throw new ArgumentException(Res.GetString(Res.WebOneWayReturnValue), "methodInfo");
}
}
XmlReflectionMember[] members = new XmlReflectionMember[inParameters.Length];
for (int i = 0; i < members.Length; i++)
{
SoapParameterInfo soapParamInfo = inParameters[i];
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapParamInfo.parameterInfo.Name;
member.MemberType = soapParamInfo.parameterInfo.ParameterType;
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
member.XmlAttributes = soapParamInfo.xmlAttributes;
member.SoapAttributes = soapParamInfo.soapAttributes;
members[i] = member;
}
soapMethod.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, requestElementName, requestNamespace, methodAttribute.requestNs == null, members, true, false, methodId, client);
if (GetSoapServiceRoutingStyle(serviceAttr) == SoapServiceRoutingStyle.RequestElement &&
soapMethod.paramStyle == SoapParameterStyle.Bare &&
soapMethod.requestMappings.Count != 1)
{
throw new ArgumentException(Res.GetString(Res.WhenUsingAMessageStyleOfParametersAsDocument0), "methodInfo");
}
string elementName = "";
string elementNamespace = "";
if (soapMethod.paramStyle == SoapParameterStyle.Bare)
{
if (soapMethod.requestMappings.Count == 1)
{
elementName = soapMethod.requestMappings[0].XsdElementName;
elementNamespace = soapMethod.requestMappings[0].Namespace;
}
// else: can't route on request element -- we match on an empty qname,
// normal rules apply for duplicates
}
else
{
elementName = soapMethod.requestMappings.XsdElementName;
elementNamespace = soapMethod.requestMappings.Namespace;
}
soapMethod.requestElementName = new XmlQualifiedName(elementName, elementNamespace);
if (!soapMethod.oneWay)
{
int numOutParams = outParameters.Length;
int count = 0;
CodeIdentifiers identifiers = null;
if (methodInfo.ReturnType != typeof(void))
{
numOutParams++;
count = 1;
identifiers = new CodeIdentifiers();
}
members = new XmlReflectionMember[numOutParams];
for (int i = 0; i < outParameters.Length; i++)
{
SoapParameterInfo soapParamInfo = outParameters[i];
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapParamInfo.parameterInfo.Name;
member.MemberType = soapParamInfo.parameterInfo.ParameterType;
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
member.XmlAttributes = soapParamInfo.xmlAttributes;
member.SoapAttributes = soapParamInfo.soapAttributes;
members[count++] = member;
if (identifiers != null)
{
identifiers.Add(member.MemberName, null);
}
}
if (methodInfo.ReturnType != typeof(void))
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = identifiers.MakeUnique(soapMethod.name + "Result");
member.MemberType = methodInfo.ReturnType;
member.IsReturnValue = true;
member.XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
member.XmlAttributes.XmlRoot = null; // Ignore XmlRoot attribute used by get/post
member.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
members[0] = member;
}
soapMethod.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, responseElementName, responseNamespace, methodAttribute.responseNs == null, members, false, false, methodId + ":Response", !client);
}
SoapExtensionAttribute[] extensionAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute));
soapMethod.extensions = new SoapReflectedExtension[extensionAttributes.Length];
for (int i = 0; i < extensionAttributes.Length; i++)
{
soapMethod.extensions[i] = new SoapReflectedExtension(extensionAttributes[i].ExtensionType, extensionAttributes[i]);
}
Array.Sort(soapMethod.extensions);
SoapHeaderAttribute[] headerAttributes = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute));
Array.Sort(headerAttributes, new SoapHeaderAttributeComparer());
Hashtable headerTypes = new Hashtable();
soapMethod.headers = new SoapReflectedHeader[headerAttributes.Length];
int front = 0;
int back = soapMethod.headers.Length;
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int i = 0; i < soapMethod.headers.Length; i++)
{
SoapHeaderAttribute headerAttribute = headerAttributes[i];
SoapReflectedHeader soapHeader = new SoapReflectedHeader();
Type declaringType = methodInfo.DeclaringType;
if ((soapHeader.memberInfo = declaringType.GetField(headerAttribute.MemberName)) != null)
{
soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType;
}
else if ((soapHeader.memberInfo = declaringType.GetProperty(headerAttribute.MemberName)) != null)
{
soapHeader.headerType = ((PropertyInfo)soapHeader.memberInfo).PropertyType;
}
else
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderMissing);
}
if (soapHeader.headerType.IsArray)
{
soapHeader.headerType = soapHeader.headerType.GetElementType();
soapHeader.repeats = true;
if (soapHeader.headerType != typeof(SoapUnknownHeader) && soapHeader.headerType != typeof(SoapHeader))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
}
}
if (MemberHelper.IsStatic(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderStatic);
}
if (!MemberHelper.CanRead(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderRead);
}
if (!MemberHelper.CanWrite(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderWrite);
}
if (!typeof(SoapHeader).IsAssignableFrom(soapHeader.headerType))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
}
SoapHeaderDirection direction = headerAttribute.Direction;
if (soapMethod.oneWay && (direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderOneWayOut);
}
if (headerTypes.Contains(soapHeader.headerType))
{
SoapHeaderDirection prevDirection = (SoapHeaderDirection)headerTypes[soapHeader.headerType];
if ((prevDirection & direction) != 0)
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebMultiplyDeclaredHeaderTypes);
}
headerTypes[soapHeader.headerType] = direction | prevDirection;
}
else
{
headerTypes[soapHeader.headerType] = direction;
}
if (soapHeader.headerType != typeof(SoapHeader) && soapHeader.headerType != typeof(SoapUnknownHeader))
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapHeader.headerType.Name;
member.MemberType = soapHeader.headerType;
XmlAttributes a = new XmlAttributes(soapHeader.headerType);
if (a.XmlRoot != null)
{
member.XmlAttributes = new XmlAttributes();
XmlElementAttribute attr = new XmlElementAttribute();
attr.ElementName = a.XmlRoot.ElementName;
attr.Namespace = a.XmlRoot.Namespace;
member.XmlAttributes.XmlElements.Add(attr);
}
member.OverrideIsNullable = true;
if ((direction & SoapHeaderDirection.In) != 0)
{
inHeaders.Add(member);
}
if ((direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
outHeaders.Add(member);
}
soapHeader.custom = true;
}
soapHeader.direction = direction;
// Put generic header mappings at the end of the list so they are found last during header processing
if (!soapHeader.custom)
{
soapMethod.headers[--back] = soapHeader;
}
else
{
soapMethod.headers[front++] = soapHeader;
}
}
soapMethod.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, requestElementName + "InHeaders", defaultNs, true, (XmlReflectionMember[])inHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":InHeaders", client);
if (!soapMethod.oneWay)
{
soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, responseElementName + "OutHeaders", defaultNs, true, (XmlReflectionMember[])outHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":OutHeaders", !client);
}
return(soapMethod);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e);
}
}