WCF-Konfiguration ohne Konfigurationsdatei

Kennt jemand ein gutes Beispiel dafür, wie ein WCF-Dienst programmgesteuert ohne Verwendung einer Konfigurationsdatei verfügbar gemacht werden kann? Ich weiß, dass das Serviceobjektmodell jetzt mit WCF viel umfangreicher ist, daher weiß ich, dass es möglich ist. Ich habe nur kein Beispiel dafür gesehen. Umgekehrt würde ich gerne sehen, wie viel Aufwand auch ohne Konfigurationsdatei gemacht wird.

Bevor jemand fragt, muss ich dies ganz speziell ohne Konfigurationsdateien tun. Normalerweise würde ich eine solche Praxis nicht empfehlen, aber wie gesagt, in diesem Fall besteht ein sehr spezifischer Bedarf.

Wie ich festgestellt habe, ist es sehr einfach, einen Webdienst ohne Konfigurationsdatei zu verwenden. Sie müssen lediglich ein Bindungsobjekt und ein Adressobjekt erstellen und diese entweder an den Konstruktor des Client-Proxys oder an eine generische ChannelFactory-Instanz übergeben. Sie können in der Standardeinstellung app.config nachsehen, welche Einstellungen verwendet werden sollen, und dann irgendwo eine statische Hilfsmethode erstellen, die Ihren Proxy instanziiert:

internal static MyServiceSoapClient CreateWebServiceInstance() {
    BasicHttpBinding binding = new BasicHttpBinding();
    // I think most (or all) of these are defaults--I just copied them from app.config:
    binding.SendTimeout = TimeSpan.FromMinutes( 1 );
    binding.OpenTimeout = TimeSpan.FromMinutes( 1 );
    binding.CloseTimeout = TimeSpan.FromMinutes( 1 );
    binding.ReceiveTimeout = TimeSpan.FromMinutes( 10 );
    binding.AllowCookies = false;
    binding.BypassProxyOnLocal = false;
    binding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
    binding.MessageEncoding = WSMessageEncoding.Text;
    binding.TextEncoding = System.Text.Encoding.UTF8;
    binding.TransferMode = TransferMode.Buffered;
    binding.UseDefaultWebProxy = true;
    return new MyServiceSoapClient( binding, new EndpointAddress( "http://www.mysite.com/MyService.asmx" ) );
}

Wenn Sie daran interessiert sind, die Verwendung des Abschnitts System.ServiceModel in der Datei web.config für IIS-Hosting zu vermeiden, habe ich hier ein Beispiel veröffentlicht ( http://bejabbers2.blogspot.com/2010/02/wcf) -zero-config-in-net-35-part-ii.html ). Ich zeige, wie Sie einen ServiceHost anpassen, um sowohl Metadaten als auch wshttpbinding-Endpunkte zu erstellen. Ich mache es auf eine allgemeine Art und Weise, die keine zusätzliche Codierung erfordert. Für diejenigen, die nicht sofort auf .NET 4.0 aktualisieren, kann dies sehr praktisch sein.

Hier ist dies vollständiger und funktionierender Code. Ich denke, es wird dir sehr helfen. Ich habe gesucht und nie einen vollständigen Code gefunden, deshalb habe ich versucht, vollständigen und funktionierenden Code einzufügen. Viel Glück.

public class ValidatorClass
{
    WSHttpBinding BindingConfig;
    EndpointIdentity DNSIdentity;
    Uri URI;
    ContractDescription ConfDescription;

    public ValidatorClass()
    {  
        // In constructor initializing configuration elements by code
        BindingConfig = ValidatorClass.ConfigBinding();
        DNSIdentity = ValidatorClass.ConfigEndPoint();
        URI = ValidatorClass.ConfigURI();
        ConfDescription = ValidatorClass.ConfigContractDescription();
    }


    public void MainOperation()
    {
         var Address = new EndpointAddress(URI, DNSIdentity);
         var Client = new EvalServiceClient(BindingConfig, Address);
         Client.ClientCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerTrust;
         Client.Endpoint.Contract = ConfDescription;
         Client.ClientCredentials.UserName.UserName = "companyUserName";
         Client.ClientCredentials.UserName.Password = "companyPassword";
         Client.Open();

         string CatchData = Client.CallServiceMethod();

         Client.Close();
    }



    public static WSHttpBinding ConfigBinding()
    {
        // ----- Programmatic definition of the SomeService Binding -----
        var wsHttpBinding = new WSHttpBinding();

        wsHttpBinding.Name = "BindingName";
        wsHttpBinding.CloseTimeout = TimeSpan.FromMinutes(1);
        wsHttpBinding.OpenTimeout = TimeSpan.FromMinutes(1);
        wsHttpBinding.ReceiveTimeout = TimeSpan.FromMinutes(10);
        wsHttpBinding.SendTimeout = TimeSpan.FromMinutes(1);
        wsHttpBinding.BypassProxyOnLocal = false;
        wsHttpBinding.TransactionFlow = false;
        wsHttpBinding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
        wsHttpBinding.MaxBufferPoolSize = 524288;
        wsHttpBinding.MaxReceivedMessageSize = 65536;
        wsHttpBinding.MessageEncoding = WSMessageEncoding.Text;
        wsHttpBinding.TextEncoding = Encoding.UTF8;
        wsHttpBinding.UseDefaultWebProxy = true;
        wsHttpBinding.AllowCookies = false;

        wsHttpBinding.ReaderQuotas.MaxDepth = 32;
        wsHttpBinding.ReaderQuotas.MaxArrayLength = 16384;
        wsHttpBinding.ReaderQuotas.MaxStringContentLength = 8192;
        wsHttpBinding.ReaderQuotas.MaxBytesPerRead = 4096;
        wsHttpBinding.ReaderQuotas.MaxNameTableCharCount = 16384;

        wsHttpBinding.ReliableSession.Ordered = true;
        wsHttpBinding.ReliableSession.InactivityTimeout = TimeSpan.FromMinutes(10);
        wsHttpBinding.ReliableSession.Enabled = false;

        wsHttpBinding.Security.Mode = SecurityMode.Message;
        wsHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;
        wsHttpBinding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;
        wsHttpBinding.Security.Transport.Realm = "";

        wsHttpBinding.Security.Message.NegotiateServiceCredential = true;
        wsHttpBinding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;
        wsHttpBinding.Security.Message.AlgorithmSuite = System.ServiceModel.Security.SecurityAlgorithmSuite.Basic256;
        // ----------- End Programmatic definition of the SomeServiceServiceBinding --------------

        return wsHttpBinding;

    }

    public static Uri ConfigURI()
    {
        // ----- Programmatic definition of the Service URI configuration -----
        Uri URI = new Uri("http://localhost:8732/Design_Time_Addresses/TestWcfServiceLibrary/EvalService/");

        return URI;
    }

    public static EndpointIdentity ConfigEndPoint()
    {
        // ----- Programmatic definition of the Service EndPointIdentitiy configuration -----
        EndpointIdentity DNSIdentity = EndpointIdentity.CreateDnsIdentity("tempCert");

        return DNSIdentity;
    }


    public static ContractDescription ConfigContractDescription()
    {
        // ----- Programmatic definition of the Service ContractDescription Binding -----
        ContractDescription Contract = ContractDescription.GetContract(typeof(IEvalService), typeof(EvalServiceClient));

        return Contract;
    }
}

Es ist auf dem Server nicht leicht Seite ..

Für die Clientseite können Sie ChannelFactory verwenden

Alle WCF-Konfigurationen können programmgesteuert durchgeführt werden. So ist es möglich, sowohl Server als auch Clients ohne Konfigurationsdatei zu erstellen.

Ich empfehle das Buch "Programming WCF Services" von Juval Lowy, das viele Beispiele für die programmatische Konfiguration enthält.

Dies ist sowohl auf Client- als auch auf Serverseite sehr einfach. Juval Lowys Buch enthält hervorragende Beispiele.

In Bezug auf Ihren Kommentar zu den Konfigurationsdateien würde ich sagen, dass die Konfigurationsdateien die zweite sind, die ein armer Mann im Code macht. Konfigurationsdateien eignen sich hervorragend, wenn Sie jeden Client steuern, der eine Verbindung zu Ihrem Server herstellt, und sicherstellen, dass sie aktualisiert werden und dass Benutzer sie nicht finden und nichts ändern können. Ich finde das WCF-Konfigurationsdateimodell einschränkend, leicht schwierig zu entwerfen und ein Wartungsalptraum. Alles in allem war es meiner Meinung nach eine sehr schlechte Entscheidung von MS, die Konfigurationsdateien zur Standardmethode zu machen.

BEARBEITEN: Mit der Konfigurationsdatei können Sie unter anderem keine Dienste mit nicht standardmäßigen Konstruktoren erstellen. Dies führt zu statischen / globalen Variablen und Singletons und anderen Arten von Unsinn in WCF.

Ich fand den Blog-Beitrag unter dem folgenden Link zu diesem Thema sehr interessant.

Eine Idee, die mir gefällt, ist die, einfach einen Bindungs- oder Verhaltens- oder Adress-XML-Abschnitt aus der Konfiguration an das entsprechende WCF-Objekt übergeben und die Zuweisung der Eigenschaften übernehmen zu lassen - derzeit ist dies nicht möglich.

Wie andere im Web habe ich Probleme damit, dass meine WCF-Implementierung eine andere Konfigurationsdatei als die meiner Hosting-Anwendung (bei der es sich um einen .NET 2.0-Windows-Dienst handelt) verwenden muss.

http://salvoz.com/blog/2007/12/09/programmatic-setting-wcf-configuration/