MTOM è sempre un requisito?

Ciao a tutti,
sapete dirmi se MTOM è ancora un requisito per SDICOOP o nell’anno trascorso sono entrati nel nuovo secolo anche loro e ora se ne può fare a meno?

Perchè non posso più rimandare di portare la mia applicazione da .NET a .NET Core, e quello che crea più problemi è che AGED richiede MTOM, abbandonato da tempo da un produttore marginale di piattaforme di sviluppo quale è Microsoft…
Altrimenti mi tocca separare in applicazioni diverse le parti, e devo lavorare tantissimo solo per fare felice IBM… :frowning:
O qualcuno ha messo a punto un modo per fare le chiamate da .NET Core?

grazie

Sì è ancora un requisito…e credo che ormai c’è lo teniamo, non mi immagino rivoluzioni così importanti sulle modalità di comunicazioni (impensabile: nuove fasi di test? “io questo non creto” cit.), al massimo qualche cambio di formato negli xml che mandano e minor fix.

Ahimè ti capisco benissimo, anch’io sono nella stessa situazione…ho un po’ di progetti “a se” in .net con le funzionalità minime per interagire con lo SDI ed il resto in Core :frowning: (su stackoverflow non ho trovato nulla per utilizzare il core per le chiamate MTOM, ergo non esiste :smiley: )

che strazio…
anche perchè a tenerle separate poi devo coordinarle, autorizzarli l’uno con l’altro ecc… una architettura a microservizi solo per parlare con un cavolo di WS, bleah
ho trovato questa accrocchiata, solo per le chiamate in uscita (che mi basterebbero, quelle in entrata le avevo già scorporate su un WS a parte per lo stesso motivo) ma non mi convince molto: https://github.com/lennykean/WcfCoreMtomEncoder

Parlano proprio di noi:

Non sviluppo in .Net quindi mi sto solo impicciando, ma date un occhio all’ultima risposta e ai link cui rimanda, magari vi è utile.

rimanda alla fine a quello stesso codice che avevo segnalato io…

Nell’ultimo post si dice che un membro di. Net core indichi una implementazione migliore di quella da te linkata (che è nel penultimo post) e si fa riferimento a questo link:

Mi riferivo a questo

1 Mi Piace

ho gettato la spugna e sto gestendo con servizi diversi distribuiti… bleah

Ciao a tutti,
condivido a beneficio della comunità il codice sorgente per NET CORE che da noi ha mandato centomila fatture. Mi sembra assurdo che dobbiate ammazzarvi a fare servizi e controservizi che si palleggiano per una mancanza di NET CORE.
La PleaseSendItToSdiAsync si potrà poi utilizzare se e quando in NET CORE metteranno MTOM; noi utilizziamo la funzione PleasSendItToSdiAsync2 che è artigianale oltre il lecito ma funziona.
Le chiamate usano RestSharp e vengono usate le strutture create attraverso il riferimento a SdIRiceviFile_v1.0.wsdl
che chiunque dovrebbe riuscire a reperire.
Chiedo umilmente scusa pubblicamente a @ivan.barbato al quale avevo promesso mesi fa il tutto, lo cito in modo che possa vedere per primo questo link.

protected async Task<rispostaSdIRiceviFile_Type> PleaseSendItToSdiAsync(fileSdIBase_Type requestData, string serviceUrl_riceviFile, string certificatePath_riceviFile, string certificatePwd_riceviFile)
            {
                var newEP = new System.ServiceModel.EndpointAddress(new Uri(serviceUrl_riceviFile));

                var newBind = new System.ServiceModel.BasicHttpBinding(System.ServiceModel.BasicHttpSecurityMode.Transport);
                newBind.Security.Transport.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.Certificate;
                //newBind.MessageEncoding = System.ServiceModel.WSMessageEncoding.Mtom;
                var certificate = new X509Certificate2(System.IO.File.ReadAllBytes(certificatePath_riceviFile), certificatePwd_riceviFile, X509KeyStorageFlags.MachineKeySet);

                using (System.ServiceModel.ChannelFactory<SdIRiceviFileChannel> factory =
                    new System.ServiceModel.ChannelFactory<SdIRiceviFileChannel>(newBind, newEP))
                {
                    factory.Credentials.ClientCertificate.Certificate = certificate;
                    using (var channel = factory.CreateChannel())
                    {
                        var request = new RiceviFileRequest(requestData);
                        RiceviFileResponse responseMessage = await channel.RiceviFileAsync(request);
                        return responseMessage.rispostaSdIRiceviFile;
                    }
                }
            }

            protected async Task<rispostaSdIRiceviFile_Type> PleaseSendItToSdiAsync2(fileSdIBase_Type requestData, string serviceUrl_riceviFile, string certificatePath_riceviFile, string certificatePwd_riceviFile)
            {
                var cert = new X509Certificate2(certificatePath_riceviFile, certificatePwd_riceviFile, X509KeyStorageFlags.UserKeySet);
                var client = new RestClient(serviceUrl_riceviFile)
                {
                    ClientCertificates = new X509CertificateCollection
                    {
                        cert
                    }
                };


                var request = new RestRequest(Method.POST);

                request.AddHeader("accept", "text/plain");
                request.AddHeader("content-type", "text/xml");

                // create parameter
                var serializer = new XmlSerializer(typeof(RiceviFileRequest));

                var requestParameter = new RiceviFileRequest(requestData);

                string requestParameterStr;

                var namepsaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
                var settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true, NamespaceHandling = NamespaceHandling.OmitDuplicates }; // some parameters to make it clean, only OmitXmlDeclaration is mandatory 
                using (var stringWriter = new StringWriter())
                {
                    using (var xmlWriter = XmlWriter.Create(stringWriter, settings))
                    {
                        serializer.Serialize(xmlWriter, requestParameter, namepsaces);
                        requestParameterStr = stringWriter.ToString();
                    }
                }

                // patch parameter to add the namespace prefix required by consumer service
                requestParameterStr = requestParameterStr.Replace("<fileSdIAccoglienza>", "<fileSdIAccoglienza xmlns=\"http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types\">");
                requestParameterStr = requestParameterStr.Replace("<NomeFile>", "<NomeFile xmlns=\"\">");
                requestParameterStr = requestParameterStr.Replace("<File>", "<File xmlns=\"\">");
                requestParameterStr = requestParameterStr.Replace("<RiceviFileRequest>", "");
                requestParameterStr = requestParameterStr.Replace("</RiceviFileRequest>", "");
                requestParameterStr = requestParameterStr.Replace("\r", "");
                requestParameterStr = requestParameterStr.Replace("\n", "");

                // wrap parameter in a soap envelop
                requestParameterStr =
                    $"<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\"><s:Header/><s:Body xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">{requestParameterStr}</s:Body></s:Envelope>";
                request.AddParameter(
                    "text/xml",
                    requestParameterStr,
                    ParameterType.RequestBody);
                ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => true;
                var response = client.Execute(request);
                if (!response.IsSuccessful)
                {
                    if (response.ErrorException != null)
                        throw response.ErrorException;
                    else
                        throw new Exception(response.ErrorMessage);
                }
                var mtomMsg = response.Content;

                // remove MTOM elements from the received Content. here comes the ugly part ^^
                /*
                 var responseContentType = response.ContentType;
                 var contentTypeElements = responseContentType.Split(";");
                 var boundary = contentTypeElements.FirstOrDefault(x => x.TrimStart().StartsWith("boundary="))?.Trim().Substring("boundary=".Length);
                 var startElement = contentTypeElements.FirstOrDefault(x => x.TrimStart().StartsWith("start="))?.Trim().Substring("start=".Length);
                 boundary = boundary.Trim('"');
                 startElement = startElement.Trim('"');

                 var startIndex = mtomMsg.IndexOf(startElement) + startElement.Length;
                 var endIndex = mtomMsg.LastIndexOf("--" + boundary + "--", startIndex);
                 */
                var startsoapenv = mtomMsg.IndexOf("<soapenv:Envelope");
                var endsoapenv = mtomMsg.IndexOf("</soapenv:Envelope>");
                var cleanedMtomMsg = mtomMsg.Substring(startsoapenv, endsoapenv - startsoapenv + 19);

                // Get the result inside the Soap envelop
                var soapDocument = XDocument.Parse(cleanedMtomMsg);

                var envelopeElt = soapDocument.Root;
                var bodyElt = (System.Xml.Linq.XElement)envelopeElt.FirstNode;
                var responseStr = bodyElt.FirstNode.ToString();

                var ret = new rispostaSdIRiceviFile_Type();
                var fn = (System.Xml.Linq.XElement)(bodyElt.FirstNode);
                foreach (var node in fn.DescendantNodes())
                {
                    if (node is XElement ne)
                    {
                        if (String.Equals(ne.Name.LocalName, "IdentificativoSdI",
                            StringComparison.CurrentCultureIgnoreCase))
                            ret.IdentificativoSdI = ne.Value;
                        else if (String.Equals(ne.Name.LocalName, "DataOraRicezione", StringComparison.CurrentCultureIgnoreCase))
                        {
                            if (DateTime.TryParse(ne.Value, out DateTime dt))
                                ret.DataOraRicezione = dt.ToUniversalTime();
                        }
                        else if (String.Equals(ne.Name.LocalName, "Errore", StringComparison.CurrentCultureIgnoreCase))
                        {
                            if (Enum.TryParse<erroreInvio_Type>(ne.Value, out erroreInvio_Type valore))
                            {
                                ret.Errore = valore;
                            }
                        }

                        else if (String.Equals(ne.Name.LocalName, "ErroreSpecified", StringComparison.CurrentCultureIgnoreCase))
                            ret.ErroreSpecified = bool.Parse(ne.Value);
                    }
                }

                return await Task.FromResult(ret);
            }
3 Mi Piace

Questa è la versione che utilizza la libreria WcfCoreMtomEncoder

public async Task<RiceviFileResponse> SdIRiceviFile(fileSdIBase_Type fileSdIBaseType) {
            var encoding = new MtomMessageEncoderBindingElement(new TextMessageEncodingBindingElement()) {
                MessageVersion = MessageVersion.CreateVersion(EnvelopeVersion.Soap11, AddressingVersion.None)
            };
            var transport = new HttpsTransportBindingElement {
                RequireClientCertificate = true
            };
            var customBinding = new CustomBinding(encoding, transport);
            var certificate = await _lazyLoader.Certificate();
            var endpoint = new EndpointAddress(new Uri(_appConfig.Value.SdIRiceviFileEndpoint));
            using var factory = new ChannelFactory<SdIRiceviFileChannel>(customBinding, endpoint);
            factory.Credentials.ServiceCertificate.SslCertificateAuthentication =
                new X509ServiceCertificateAuthentication {
                    CertificateValidationMode = X509CertificateValidationMode.None,
                    RevocationMode = X509RevocationMode.NoCheck
                };
            factory.Credentials.ClientCertificate.Certificate = certificate;
            using var channel = factory.CreateChannel();
            var request = new RiceviFileRequest(fileSdIBaseType);
            var responseMessage = await channel.RiceviFileAsync(request);
            return responseMessage;
        }
2 Mi Piace

Condivido anche io a beneficio di tutti gli interessati il codice .NET CORE 5 autogenerato da linea di comando con il tool
dotnet-svcutil SdIRiceviFile_v1.0.wsdl

Il codice è simile a quello di @Antonio_Gabriele perchè ho utilizzato anche io la libreria WcfCoreMtomEncoder per il MTOM, ma anzichè istanziare una ChannelFactory ho incluso il set up del CustomBinding direttamente nel metodo GetBindingForEndpoint di SdIRiceviFileClient, e ho invece lasciato il set up del certificato esternamente in InviaFattura.

Il risultato è il seguente e funziona in .NET CORE 5

//------------------------------------------------------------------------------
// <auto-generated>
//     Questo codice è stato generato da uno strumento.
//
//     Le modifiche apportate a questo file possono causare un comportamento non corretto e andranno perse se
//     il codice viene rigenerato.
// </auto-generated>
//------------------------------------------------------------------------------



[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.ServiceModel.ServiceContractAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0", ConfigurationName = "SdIRiceviFile")]
public interface SdIRiceviFile
{

    [System.ServiceModel.OperationContractAttribute(Action = "http://www.fatturapa.it/SdIRiceviFile/RiceviFile", ReplyAction = "*")]
    [System.ServiceModel.XmlSerializerFormatAttribute(SupportFaults = true)]
    System.Threading.Tasks.Task<RiceviFileResponse> RiceviFileAsync(RiceviFileRequest request);
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types")]
public partial class fileSdIBase_Type
{

    private string nomeFileField;

    private byte[] fileField;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified, Order = 0)]
    public string NomeFile
    {
        get
        {
            return this.nomeFileField;
        }
        set
        {
            this.nomeFileField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified, DataType = "base64Binary", Order = 1)]
    public byte[] File
    {
        get
        {
            return this.fileField;
        }
        set
        {
            this.fileField = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types")]
public partial class rispostaSdIRiceviFile_Type
{

    private string identificativoSdIField;

    private System.DateTime dataOraRicezioneField;

    private erroreInvio_Type erroreField;

    private bool erroreFieldSpecified;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified, DataType = "integer", Order = 0)]
    public string IdentificativoSdI
    {
        get
        {
            return this.identificativoSdIField;
        }
        set
        {
            this.identificativoSdIField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified, Order = 1)]
    public System.DateTime DataOraRicezione
    {
        get
        {
            return this.dataOraRicezioneField;
        }
        set
        {
            this.dataOraRicezioneField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Form = System.Xml.Schema.XmlSchemaForm.Unqualified, Order = 2)]
    public erroreInvio_Type Errore
    {
        get
        {
            return this.erroreField;
        }
        set
        {
            this.erroreField = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlIgnoreAttribute()]
    public bool ErroreSpecified
    {
        get
        {
            return this.erroreFieldSpecified;
        }
        set
        {
            this.erroreFieldSpecified = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types")]
public enum erroreInvio_Type
{

    /// <remarks/>
    EI01,

    /// <remarks/>
    EI02,

    /// <remarks/>
    EI03,
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
[System.ServiceModel.MessageContractAttribute(IsWrapped = false)]
public partial class RiceviFileRequest
{

    [System.ServiceModel.MessageBodyMemberAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types", Order = 0)]
    public fileSdIBase_Type fileSdIAccoglienza;

    public RiceviFileRequest()
    {
    }

    public RiceviFileRequest(fileSdIBase_Type fileSdIAccoglienza)
    {
        this.fileSdIAccoglienza = fileSdIAccoglienza;
    }
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
[System.ServiceModel.MessageContractAttribute(IsWrapped = false)]
public partial class RiceviFileResponse
{

    [System.ServiceModel.MessageBodyMemberAttribute(Namespace = "http://www.fatturapa.gov.it/sdi/ws/trasmissione/v1.0/types", Order = 0)]
    public rispostaSdIRiceviFile_Type rispostaSdIRiceviFile;

    public RiceviFileResponse()
    {
    }

    public RiceviFileResponse(rispostaSdIRiceviFile_Type rispostaSdIRiceviFile)
    {
        this.rispostaSdIRiceviFile = rispostaSdIRiceviFile;
    }
}

[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
public interface SdIRiceviFileChannel : SdIRiceviFile, System.ServiceModel.IClientChannel
{
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.Svcutil", "2.0.3")]
public partial class SdIRiceviFileClient : System.ServiceModel.ClientBase<SdIRiceviFile>, SdIRiceviFile
{

    /// <summary>
    /// Implementare questo metodo parziale per configurare l'endpoint servizio.
    /// </summary>
    /// <param name="serviceEndpoint">Endpoint da configurare</param>
    /// <param name="clientCredentials">Credenziali del client</param>
    static partial void ConfigureEndpoint(System.ServiceModel.Description.ServiceEndpoint serviceEndpoint, System.ServiceModel.Description.ClientCredentials clientCredentials);

    public SdIRiceviFileClient() :
            base(SdIRiceviFileClient.GetDefaultBinding(), SdIRiceviFileClient.GetDefaultEndpointAddress())
    {
        this.Endpoint.Name = EndpointConfiguration.SdIRiceviFile_port.ToString();
        ConfigureEndpoint(this.Endpoint, this.ClientCredentials);
    }

    public SdIRiceviFileClient(EndpointConfiguration endpointConfiguration) :
            base(SdIRiceviFileClient.GetBindingForEndpoint(endpointConfiguration), SdIRiceviFileClient.GetEndpointAddress(endpointConfiguration))
    {
        this.Endpoint.Name = endpointConfiguration.ToString();
        ConfigureEndpoint(this.Endpoint, this.ClientCredentials);
    }

    public SdIRiceviFileClient(EndpointConfiguration endpointConfiguration, string remoteAddress) :
            base(SdIRiceviFileClient.GetBindingForEndpoint(endpointConfiguration), new System.ServiceModel.EndpointAddress(remoteAddress))
    {
        this.Endpoint.Name = endpointConfiguration.ToString();
        ConfigureEndpoint(this.Endpoint, this.ClientCredentials);
    }

    public SdIRiceviFileClient(EndpointConfiguration endpointConfiguration, System.ServiceModel.EndpointAddress remoteAddress) :
            base(SdIRiceviFileClient.GetBindingForEndpoint(endpointConfiguration), remoteAddress)
    {
        this.Endpoint.Name = endpointConfiguration.ToString();
        ConfigureEndpoint(this.Endpoint, this.ClientCredentials);
    }

    public SdIRiceviFileClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
            base(binding, remoteAddress)
    {
    }

    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
    System.Threading.Tasks.Task<RiceviFileResponse> SdIRiceviFile.RiceviFileAsync(RiceviFileRequest request)
    {
        return base.Channel.RiceviFileAsync(request);
    }

    public System.Threading.Tasks.Task<RiceviFileResponse> RiceviFileAsync(fileSdIBase_Type fileSdIAccoglienza)
    {
        RiceviFileRequest inValue = new RiceviFileRequest();
        inValue.fileSdIAccoglienza = fileSdIAccoglienza;
        return ((SdIRiceviFile)(this)).RiceviFileAsync(inValue);
    }

    public virtual System.Threading.Tasks.Task OpenAsync()
    {
        return System.Threading.Tasks.Task.Factory.FromAsync(((System.ServiceModel.ICommunicationObject)(this)).BeginOpen(null, null), new System.Action<System.IAsyncResult>(((System.ServiceModel.ICommunicationObject)(this)).EndOpen));
    }

    public virtual System.Threading.Tasks.Task CloseAsync()
    {
        return System.Threading.Tasks.Task.Factory.FromAsync(((System.ServiceModel.ICommunicationObject)(this)).BeginClose(null, null), new System.Action<System.IAsyncResult>(((System.ServiceModel.ICommunicationObject)(this)).EndClose));
    }

    private static System.ServiceModel.Channels.Binding GetBindingForEndpoint(EndpointConfiguration endpointConfiguration)
    {
        if ((endpointConfiguration == EndpointConfiguration.SdIRiceviFile_port))
        {
            var encoding = new WcfCoreMtomEncoder.MtomMessageEncoderBindingElement(new System.ServiceModel.Channels.TextMessageEncodingBindingElement())
            {
                MessageVersion = System.ServiceModel.Channels.MessageVersion.CreateVersion(System.ServiceModel.EnvelopeVersion.Soap11, System.ServiceModel.Channels.AddressingVersion.None)
            };
            var transport = new System.ServiceModel.Channels.HttpsTransportBindingElement
            {
                RequireClientCertificate = true                
            };
            var customBinding = new System.ServiceModel.Channels.CustomBinding(encoding, transport);
            return customBinding;
        }
        throw new System.InvalidOperationException(string.Format("L\'endpoint denominato \'{0}\' non è stato trovato.", endpointConfiguration));
    }

    private static System.ServiceModel.EndpointAddress GetEndpointAddress(EndpointConfiguration endpointConfiguration)
    {
        if ((endpointConfiguration == EndpointConfiguration.SdIRiceviFile_port))
        {
            return new System.ServiceModel.EndpointAddress("https://servizi.fatturapa.it/ricevi_file");
        }
        throw new System.InvalidOperationException(string.Format("L\'endpoint denominato \'{0}\' non è stato trovato.", endpointConfiguration));
    }

    private static System.ServiceModel.Channels.Binding GetDefaultBinding()
    {
        return SdIRiceviFileClient.GetBindingForEndpoint(EndpointConfiguration.SdIRiceviFile_port);
    }

    private static System.ServiceModel.EndpointAddress GetDefaultEndpointAddress()
    {
        return SdIRiceviFileClient.GetEndpointAddress(EndpointConfiguration.SdIRiceviFile_port);
    }

    public enum EndpointConfiguration
    {

        SdIRiceviFile_port,
    }
}



public class SdIClient
{
    public string InviaFattura(string path)
    {
        RiceviFileResponse res;

        fileSdIBase_Type file = new fileSdIBase_Type();
        file.File = System.IO.File.ReadAllBytes(path);
        file.NomeFile = System.IO.Path.GetFileName(path);


        using (SdIRiceviFileClient client = new SdIRiceviFileClient())
        {
            // HTTP Proxy
            foreach (System.ServiceModel.Channels.BindingElement be in ((System.ServiceModel.Channels.CustomBinding)client.ChannelFactory.Endpoint.Binding).Elements)
            {
                System.Type thisType = be.GetType();
                if (be is System.ServiceModel.Channels.HttpTransportBindingElement)
                {
                    System.ServiceModel.Channels.HttpTransportBindingElement httpElement = (System.ServiceModel.Channels.HttpTransportBindingElement)be;
                    httpElement.Proxy = new System.Net.WebProxy("my-proxy-server");
                    httpElement.Proxy.Credentials = new System.Net.NetworkCredential("user", "password");
                }
            }

            // Certificato
            System.Security.Cryptography.X509Certificates.X509Certificate2 certClient =
                new System.Security.Cryptography.X509Certificates.X509Certificate2(System.IO.File.ReadAllBytes("\path\to\SDIClient-pk.pfx"), "password", System.Security.Cryptography.X509Certificates.X509KeyStorageFlags.Exportable);

            client.ClientCredentials.ClientCertificate.Certificate = certClient;

            client.ClientCredentials.ServiceCertificate.SslCertificateAuthentication =
                new System.ServiceModel.Security.X509ServiceCertificateAuthentication
                {
                    CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None,
                    RevocationMode = System.Security.Cryptography.X509Certificates.X509RevocationMode.NoCheck
                };

            res = System.Threading.Tasks.Task.Run(() => client.RiceviFileAsync(file)).GetAwaiter().GetResult();

        }

        return res.rispostaSdIRiceviFile.IdentificativoSdI;
    }
}

1 Mi Piace