current OperationContext, WCF Windows Service'de sıfırdır.

Question

WCF sunucusunu kullanarak ve WCF sunucusunun bir Windows hizmetinde bulunduğu bir Yayınlama/Abone Olma sistemi kurmaya çalışıyorum. Bağlama net.TCP'dir. Hizmet, istemciye bir "Abone Ol" yöntemini sağlamaktadır, böylece istemci bir sunucuya bağlı bir DLL'den yükseltilecek bir olaya bir geri çağırma işleyicisi kaydedebilir. Abone ol yönteminde OperationContext.Current.GetCallbackChannel yöntemini kullanarak geri arama kanalı elde etmeye çalışıyorum. Bunu denediğimde OperationContext.Current özelliği NULL değerini döndürür.

Bu mülkün hangi şartlar altında geri döneceğini bana kim söyleyebilir? Bir şey ayarlamayı özledim mi? Servis kodunu ve aşağıdaki arayüz kodunu ekleyeceğim. Visual Studio 2012'de C# kullanıyorum ve framework 4.5'ü hedefliyorum.

Hizmeti:

namespace WService 
{ 
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)] 
public class WcfPublisherService : IWcfPublisherContract 
{ 
    IOALogic logic = new OAControlExample(); 
    IWcfSubscriberContract _callback = null; 

    public void Subscribe() 
    { 
     _callback = OperationContext.Current.GetCallbackChannel<IWcfSubscriberContract>(); 
     logic.BarriersChanged += logic_BarriersChanged; 
    } 

    public void UnSubscribe() 
    { 
     logic.BarriersChanged -= logic_BarriersChanged; 
    } 

    void logic_BarriersChanged(object sender, BarriersChangedEventArgs e) 
    { 
     _callback.BarriersChanged(e.BarrierLines); 
    } 
} 
} 

Arayüz:

namespace WService 
{ 
[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IWcfSubscriberContract))] 
public interface IWcfPublisherContract 
{ 
    [OperationContract(IsOneWay=false, IsInitiating=true)] 
    void Subscribe(); 
    [OperationContract(IsOneWay = false, IsTerminating=true)] 
    void UnSubscribe(); 
} 

public interface IWcfSubscriberContract 
{ 
    [OperationContract(IsOneWay = true)] 
    void BarriersChanged(BarrierLines barrierLines); 
} 
} 

Müşteri:

namespace TestClient 
{ 
public partial class Form1 : Form 
{ 
    WcfPublisherService myService 
     = new WcfPublisherService(); 

    ServiceCallback serviceCallback = new ServiceCallback(); 

    public Form1() 
    { 
     InitializeComponent(); 
     serviceCallback.NewMessage += serviceCallback_NewMessage; 
    } 

    private delegate void serviceCallback_NewMessageDelegate(object sender, NewMessageEventArgs e); 
    void serviceCallback_NewMessage(object sender, NewMessageEventArgs e) 
    { 
     if (textBox1.InvokeRequired) 
     { 
      textBox1.Invoke(new serviceCallback_NewMessageDelegate(serviceCallback_NewMessage), new object[] {sender, e}); 
     } 
     else 
     { 
      if (textBox1.Text.Trim().Length > 1) 
      { 
       textBox1.Text += Environment.NewLine; 
      } 
      textBox1.Text += e.Msg; 
     } 
    } 

    private void button1_Click(object sender, EventArgs e) 
    { 
     myService.Subscribe(); 
    } 

    private void button2_Click(object sender, EventArgs e) 
    { 
     myService.UnSubscribe(); 
    } 
} 

[CallbackBehaviorAttribute(UseSynchronizationContext = false)] 
class ServiceCallback : IWcfSubscriberContract 
{ 
    public delegate void NewMessageEventHandler(object sender, NewMessageEventArgs e); 
    public event NewMessageEventHandler NewMessage; 
    protected virtual void OnNewMessage(string msg) 
    { 
     if (NewMessage != null) 
     { 
      NewMessage(this, new NewMessageEventArgs(msg)); 
     } 
    } 

    public void BarriersChanged(OA.BarrierLines barrierLines) 
    { 
     OnNewMessage("new barrier lines"); 
    } 
} 

public class NewMessageEventArgs : EventArgs 
{ 
    public NewMessageEventArgs(string msg) 
    { 
     this.Msg = msg; 
    } 
    public string Msg { get; set; } 
} 
} 

** * ** * ** * Yeni Düzenleme * ** * ** * ** * ** * ** SalientBrain önerilerine sayesinde, benim projeye önemli değişiklikler yaptık çünkü servisin uzun süre koşması gerektiğini ve hiçbir müşterinin bağlı olmasa bile sürekli çalışmasını sağladığımı fark ettim, böylece bir singletona değiştirdim. Yine de, orijinal problemim hala devam ediyor. SalientBrain, config dosyamı görmeyi istedi, böylece diğer tüm ilgili dosyalar ile birlikte aşağıda ekleyeceğim. Alanı korumak için çıkardım ama önemli bir şey çıkardığımı sanmıyorum. Hata, PulisherService sınıfının Abone yönteminde gerçekleşir. Umarım yapılandırma dosyasında yaptığım aptalca bir şeydir. Eh, işte burada:

Yapılandırma:

<configuration> 
    <startup> 
     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> 
    </startup> 
    <system.serviceModel> 
     <behaviors> 
      <serviceBehaviors> 
       <behavior name="WService.WCFPublisherServiceBehavior"> 
        <serviceMetadata httpGetEnabled="false" httpsGetEnabled="false" /> 
        <serviceDebug includeExceptionDetailInFaults="false" /> 
       </behavior> 
      </serviceBehaviors> 
     </behaviors> 
     <services> 
      <service behaviorConfiguration="WService.WCFPublisherServiceBehavior" 
       name="WService.WcfPublisherService"> 
       <endpoint address="" binding="netTcpBinding" bindingConfiguration="" 
        name="NetTcpBindingEndpoint" contract="WService.IWcfPublisherContract"> 
        <identity> 
         <dns value="localhost" /> 
        </identity> 
       </endpoint> 
       <endpoint address="mex" binding="mexTcpBinding" bindingConfiguration="" 
        name="MexTcpBindingEndpoint" contract="IMetadataExchange" /> 
       <host> 
        <baseAddresses> 
         <add baseAddress="net.tcp://localhost:8523/Publisher" /> 
        </baseAddresses> 
       </host> 
      </service> 
     </services> 
    </system.serviceModel> 
</configuration> 

WcfContracts:

namespace WService 
{ 
    [ServiceContract(SessionMode = SessionMode.Allowed, CallbackContract = typeof(IWcfSubscriberContract))] 
    public interface IWcfPublisherContract 
    { 
     [OperationContract(IsOneWay=false)] 
     void Subscribe(string key); 
     [OperationContract(IsOneWay = false)] 
     void UnSubscribe(string key); 
    } 

    public interface IWcfSubscriberContract 
    { 
     [OperationContract(IsOneWay = true)] 
     void BarriersChanged(BarrierLines barrierLines); 
    } 
} 

WcfService:

namespace WService 
{ 
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)] 
    public class WcfPublisherService : IWcfPublisherContract 
    { 
     private static WcfPublisherService _instance = null; 
     private IOALogic _logic = null; 
     private Dictionary<string, IWcfSubscriberContract> _callbacks 
      = new Dictionary<string, IWcfSubscriberContract>(); 
     private ReaderWriterLock _callbacksLock = new ReaderWriterLock(); 

     private WcfPublisherService() { } 

     public static WcfPublisherService TheInstance() 
     { 
      if (_instance == null) 
      { 
       _instance = new WcfPublisherService(); 
      } 
      return _instance; 
     } 

     public void StopWcf() 
     { 
      _logic.StopRequest(); 
     } 

     public void StartWcf(IOALogic logic) 
     { 
      _logic = logic; 
      _logic.BarriersChanged += logic_BarriersChanged; 
      ThreadPool.QueueUserWorkItem(new WaitCallback(StartWork), null); 
     } 

     public void StartWork(object state) 
     { 
      _logic.Run(); 
     } 

     public void Subscribe(string key) 
     { 
      OperationContext context = OperationContext.Current; 
      // The above line returns null *********************************************** 
      _callbacksLock.AcquireWriterLock(2000); 
      if (_callbacksLock.IsWriterLockHeld) 
      { 
       _callbacks.Add(key, context.GetCallbackChannel<IWcfSubscriberContract>()); 
       // The above line throws a null execption because context is null ******** 
       _callbacksLock.ReleaseWriterLock(); 
      } 
     } 

     public void UnSubscribe(string key) 
     { 
      _callbacksLock.AcquireWriterLock(2000); 
      if (_callbacksLock.IsWriterLockHeld) 
      { 
       _callbacks.Remove(key); 
       _callbacksLock.ReleaseWriterLock(); 
      } 
     } 

     void logic_BarriersChanged(object sender, BarriersChangedEventArgs e) 
     { 
      _callbacksLock.AcquireReaderLock(1000); 
      if (_callbacksLock.IsReaderLockHeld) 
      { 
       try 
       { 
        foreach (IWcfSubscriberContract callback in _callbacks.Values) 
        { 
         callback.BarriersChanged(e.BarrierLines); 
        } 
       } 
       finally 
       { 
        _callbacksLock.ReleaseReaderLock(); 
       } 
      } 
     } 
    } 
} 

Windowsservice:

namespace WService 
{ 
    public partial class WService : ServiceBase 
    { 
     internal static ServiceHost _serviceHost = null; 
     internal static IOALogic _logic = new OAControlExample(); 

     public WService() 
     { 
      InitializeComponent(); 
     } 

     protected override void OnStart(string[] args) 
     { 
      if (_serviceHost != null) 
      { 
       _serviceHost.Close(); 
      } 

      _serviceHost = new ServiceHost(WcfPublisherService.TheInstance()); 
      WcfPublisherService.TheInstance().StartWcf(_logic); 
      _serviceHost.Open(); 
     } 

     protected override void OnStop() 
     { 
      if (WcfPublisherService.TheInstance() != null) 
      { 
       WcfPublisherService.TheInstance().StopWcf(); 
      } 
      if (_serviceHost != null) 
      { 
       _serviceHost.Close(); 
       _serviceHost = null; 
      } 
     } 
    } 
} 

TestForm:

namespace TestClient 
{ 
    public partial class Form1 : Form 
    { 
     ServiceCallback serviceCallback = new ServiceCallback(); 

     public Form1() 
     { 
      InitializeComponent(); 

      serviceCallback.NewMessage += serviceCallback_NewMessage; 
     } 

     private delegate void serviceCallback_NewMessageDelegate(object sender, NewMessageEventArgs e); 
     void serviceCallback_NewMessage(object sender, NewMessageEventArgs e) 
     { 
      if (textBox1.InvokeRequired) 
      { 
       textBox1.Invoke(new serviceCallback_NewMessageDelegate(serviceCallback_NewMessage), new object[] {sender, e}); 
      } 
      else 
      { 
       if (textBox1.Text.Trim().Length > 1) 
       { 
        textBox1.Text += Environment.NewLine; 
       } 
       textBox1.Text += e.Msg; 
      } 
     } 

     private void button1_Click(object sender, EventArgs e) 
     { 
      serviceCallback.Subscribe(); 
     } 

     private void button2_Click(object sender, EventArgs e) 
     { 
      serviceCallback.Unsubscribe(); 
     } 
    } 
} 

TestCallbackClass: doğrudan hizmet türü örneği oluşturursanız, yorum tartışıldığı gibi

namespace TestClient 
{ 
    [CallbackBehaviorAttribute(UseSynchronizationContext = true)] 
    class ServiceCallback : IWcfSubscriberContract 
    { 
     WcfPublisherService myService 
      = WcfPublisherService.TheInstance(); 
     string callbackKey = Guid.NewGuid().ToString(); 

     public delegate void NewMessageEventHandler(object sender, NewMessageEventArgs e); 
     public event NewMessageEventHandler NewMessage; 
     protected virtual void OnNewMessage(string msg) 
     { 
      if (NewMessage != null) 
      { 
       NewMessage(this, new NewMessageEventArgs(msg)); 
      } 
     } 

     public void Subscribe() 
     { 
      try 
      { 
       myService.Subscribe(callbackKey); 
      } 
      catch (Exception ex) 
      { 
       OnNewMessage("exception: " + ex.Message); 
      } 
     } 

     public void Unsubscribe() 
     { 
      try 
      { 
       myService.UnSubscribe(callbackKey); 
      } 
      catch (Exception ex) 
      { 
       OnNewMessage("exception: " + ex.Message); 
      } 
     } 

     public void BarriersChanged(OAInterface.BarrierLines barrierLines) 
     { 
      OnNewMessage("new barrier lines"); 
     } 
    } 

    public class NewMessageEventArgs : EventArgs 
    { 
     public NewMessageEventArgs(string msg) 
     { 
      this.Msg = msg; 
     } 
     public string Msg { get; set; } 
    } 
} 

Answer 1

- o zaman arayıp - WCF proxy/clientchannel aksine Üzerinde bir yöntem, OperationContext yoktur. WCF, işleminiz bir hizmet içinde çalışırken bir OperationContext örneği sağlar.

Answer 2

İstemci kodunda, vekil sunucu tarafından oluşturulmadı. Hizmet sınıfı örneği bir sınıf kitaplığı olarak oluşturulur.

Sen kod

ServiceCallback serviceCallback = new ServiceCallback(); 
InstanceContext instanceContext = new InstanceContext(serviceCallback); 

var pubsubProxy = new PubSubProxy.WcfPublisherContractClient(instanceContext); 
pubsubProxy.Subscribe(); 

aşağıdaki gibi hizmet tüketmek gerekir Ve hizmet çalışırken, OperationContext oluşturulur ve ben benzer bir sorunu vardı OperationContext.Current

Answer 3

erişebilir: benim durumumda ne zaman InstanceContextMode, WebOperationContext.Current tek yapıcıda null olarak ayarlandı. Ancak hizmet/sınıf yöntemleri içinde mevcuttu.