web-dev-qa-db-ja.com

WCF ChannelFactory <T>の作成

既存の.NET RemotingアプリケーションをWCFに変換しようとしています。サーバーとクライアントの両方が共通のインターフェースを共有し、すべてのオブジェクトはサーバー起動オブジェクトです。

WCFの世界では、これは呼び出しごとのサービスを作成し、_ChannelFactory<T>_を使用してプロキシを作成することに似ています。 ASP.NETクライアント用に_ChannelFactory<T>_を適切に作成する方法に少し苦労しています。

パフォーマンス上の理由から、_ChannelFactory<T>_オブジェクトをキャッシュし、サービスを呼び出すたびにチャネルを作成するだけです。 .NETリモーティング時代には、RemotingConfiguration.GetRegisteredWellknownClientTypes()メソッドを使用して、キャッシュできるクライアントオブジェクトのコレクションを取得していました。構成ファイルからエンドポイントのコレクションを取得することはできましたが、WCFの世界ではそのようなことはありません。

今ここに私が働くと思うものがあります。次のようなものを作成できます。

_public static ProxyHelper
{
    static Dictionary<Type, object> lookup = new Dictionary<string, object>();  

    static public T GetChannel<T>()
    {
        Type type = typeof(T);
        ChannelFactory<T> factory;

        if (!lookup.ContainsKey(type))
        {
            factory = new ChannelFactory<T>();
            lookup.Add(type, factory);
        }
        else
        {
            factory = (ChannelFactory<T>)lookup[type];
        }

        T proxy = factory.CreateChannel();   
        ((IClientChannel)proxy).Open();

        return proxy;
    }    
}
_

上記のコードは機能すると思いますが、ルックアップにない場合、複数のスレッドが新しい_ChannelFactory<T>_オブジェクトを追加しようとするのが少し心配です。 .NET 4.0を使用しているので、ConcurrentDictionaryを使用してGetOrAdd()メソッドを使用するか、最初にTryGetValue()メソッドを使用して_ChannelFactory<T>_が存在するかどうかを検討していました存在しない場合は、GetOrAdd()メソッドを使用します。 ConcurrentDictionary.TryGetValue()およびConcurrentDictionary.GetOrAdd()メソッドのパフォーマンスについてはわかりません。

もう1つの小さな質問は、ASP.NETアプリケーションの終了後にチャネルファクトリオブジェクトでChannelFactory.Close()メソッドを呼び出す必要があるか、または.NETフレームワークでチャネルファクトリオブジェクトを単独で破棄できるかどうかです。 _((IChannel)proxy).Close()_メソッドを使用してサービスメソッドを呼び出した後、プロキシチャネルは常に閉じられます。

c#.netwcfc#-4.0channelfactory
45
Eric

はい、このような何か-_ChannelFactory<T>_インスタンスをすべて保持する静的クラス-を作成したい場合、このクラスが100％スレッドセーフであり、同時にアクセスしたときにつまずかないようにする必要があります。私はまだ.NET 4の機能をあまり使用していないので、それらについて具体的にコメントすることはできませんが、これを可能な限り安全にすることをお勧めします。

2番目の（マイナーな）質問については、ChannelFactory自体が静的クラスです。したがって、.Close()メソッドを実際に呼び出すことはできません。実際のIChannelで.Close()メソッドを呼び出すかどうかを尋ねる場合は、もう一度：はい、できる限り善良な市民になり、それらのチャネルを閉じます。見逃した場合、.NETが面倒をみますが、使用されていないチャンネルを床に放り込んで先に進むのではなく、自分で片付けてください！ :-)

13
marc_s

チャネルファクトリを処理するために使用するヘルパークラスを次に示します。

public class ChannelFactoryManager : IDisposable
{
    private static Dictionary<Type, ChannelFactory> _factories = new Dictionary<Type,ChannelFactory>();
    private static readonly object _syncRoot = new object();

    public virtual T CreateChannel<T>() where T : class
    {
        return CreateChannel<T>("*", null);
    }

    public virtual T CreateChannel<T>(string endpointConfigurationName) where T : class
    {
        return CreateChannel<T>(endpointConfigurationName, null);
    }

    public virtual T CreateChannel<T>(string endpointConfigurationName, string endpointAddress) where T : class
    {
        T local = GetFactory<T>(endpointConfigurationName, endpointAddress).CreateChannel();
        ((IClientChannel)local).Faulted += ChannelFaulted;
        return local;
    }

    protected virtual ChannelFactory<T> GetFactory<T>(string endpointConfigurationName, string endpointAddress) where T : class
    {
        lock (_syncRoot)
        {
            ChannelFactory factory;
            if (!_factories.TryGetValue(typeof(T), out factory))
            {
                factory = CreateFactoryInstance<T>(endpointConfigurationName, endpointAddress);
                _factories.Add(typeof(T), factory);
            }
            return (factory as ChannelFactory<T>);
        }
    }

    private ChannelFactory CreateFactoryInstance<T>(string endpointConfigurationName, string endpointAddress)
    {
        ChannelFactory factory = null;
        if (!string.IsNullOrEmpty(endpointAddress))
        {
            factory = new ChannelFactory<T>(endpointConfigurationName, new EndpointAddress(endpointAddress));
        }
        else
        {
            factory = new ChannelFactory<T>(endpointConfigurationName);
        }
        factory.Faulted += FactoryFaulted;
        factory.Open();
        return factory;
    }

    private void ChannelFaulted(object sender, EventArgs e)
    {
        IClientChannel channel = (IClientChannel)sender;
        try
        {
            channel.Close();
        }
        catch
        {
            channel.Abort();
        }
        throw new ApplicationException("Exc_ChannelFailure");
    }

    private void FactoryFaulted(object sender, EventArgs args)
    {
        ChannelFactory factory = (ChannelFactory)sender;
        try
        {
            factory.Close();
        }
        catch
        {
            factory.Abort();
        }
        Type[] genericArguments = factory.GetType().GetGenericArguments();
        if ((genericArguments != null) && (genericArguments.Length == 1))
        {
            Type key = genericArguments[0];
            if (_factories.ContainsKey(key))
            {
                _factories.Remove(key);
            }
        }
        throw new ApplicationException("Exc_ChannelFactoryFailure");
    }

    public void Dispose()
    {
        Dispose(true);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            lock (_syncRoot)
            {
                foreach (Type type in _factories.Keys)
                {
                    ChannelFactory factory = _factories[type];
                    try
                    {
                        factory.Close();
                        continue;
                    }
                    catch
                    {
                        factory.Abort();
                        continue;
                    }
                }
                _factories.Clear();
            }
        }
    }
}

次に、サービス呼び出しを定義します。

public interface IServiceInvoker
{
    R InvokeService<T, R>(Func<T, R> invokeHandler) where T: class;
}

および実装：

public class WCFServiceInvoker : IServiceInvoker
{
    private static ChannelFactoryManager _factoryManager = new ChannelFactoryManager();
    private static ClientSection _clientSection = ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection;

    public R InvokeService<T, R>(Func<T, R> invokeHandler) where T : class
    {
        var endpointNameAddressPair = GetEndpointNameAddressPair(typeof(T));
        T arg = _factoryManager.CreateChannel<T>(endpointNameAddressPair.Key, endpointNameAddressPair.Value);
        ICommunicationObject obj2 = (ICommunicationObject)arg;
        try
        {
            return invokeHandler(arg);
        }
        finally
        {
            try
            {
                if (obj2.State != CommunicationState.Faulted)
                {
                    obj2.Close();
                }
            }
            catch
            {
                obj2.Abort();
            }
        }
    }

    private KeyValuePair<string, string> GetEndpointNameAddressPair(Type serviceContractType)
    {
        var configException = new ConfigurationErrorsException(string.Format("No client endpoint found for type {0}. Please add the section <client><endpoint name=\"myservice\" address=\"http://address/\" binding=\"basicHttpBinding\" contract=\"{0}\"/></client> in the config file.", serviceContractType));
        if (((_clientSection == null) || (_clientSection.Endpoints == null)) || (_clientSection.Endpoints.Count < 1))
        {
            throw configException;
        }
        foreach (ChannelEndpointElement element in _clientSection.Endpoints)
        {
            if (element.Contract == serviceContractType.ToString())
            {
                return new KeyValuePair<string, string>(element.Name, element.Address.AbsoluteUri);
            }
        }
        throw configException;
    }

}

これで、WCFサービスを呼び出す必要があるたびに、これを使用できます。

WCFServiceInvoker invoker = new WCFServiceInvoker();
SomeReturnType result = invoker.InvokeService<IMyServiceContract, SomeReturnType>(
    proxy => proxy.SomeMethod()
);

これは、設定ファイルでIMyServiceContractサービスコントラクトのクライアントエンドポイントを定義していることを前提としています。

<client>
    <endpoint 
        name="myservice" 
        address="http://example.com/" 
        binding="basicHttpBinding" 
        contract="IMyServiceContract" />
</client>
64
Darin Dimitrov

私は呼び出し構造が好きではありませんでした：

WCFServiceInvoker invoker = new WCFServiceInvoker();
var result = invoker.InvokeService<IClaimsService, ICollection<string>>(proxy => proxy.GetStringClaims());

また、同じチャネルを2回使用することはできません。

私はこのソリューションを作成しました：

using(var i = Connection<IClaimsService>.Instance)
{           
   var result = i.Channel.GetStringClaims();
}

Usingステートメントがdisposeを呼び出すまで、同じチャンネルを再利用できます。

GetChannelメソッドは、基本的にChannelFactory.CreateChannel（）で、私が使用している追加の構成がいくつかあります。

他のソリューションと同様に、ChannelFactoryのキャッシュを構築できます。

Connnectionクラスのコード：

public static class Connection<T>
   {
      public static ChannelHolder Instance
      {
         get
         {
            return new ChannelHolder();
         }
      }

      public class ChannelHolder : IDisposable
      {
         public T Channel { get; set; }

         public ChannelHolder()
         {
            this.Channel = GetChannel();
         }

         public void Dispose()
         {
            IChannel connection = null;
            try
            {
               connection = (IChannel)Channel;
               connection.Close();
            }
            catch (Exception)
            {
               if (connection != null)
               {
                  connection.Abort();
               }
            }
         }
      }
}
2
Max

@NelsonRothermel、はい、ChannelFactoryManager ChannelFaultedイベントハンドラーでtry catchを使用しない道を進みました。したがって、ChannelFaultedは

 private void ChannelFaulted(object sender, EventArgs e)
    {
        IClientChannel channel = (IClientChannel)sender;            
        channel.Abort();
    }

元の例外がバブルアップするのを許可しているようです。また、channel.closeを使用しないことも選択しました。これは、チャネルが既に障害状態にあるため、例外をスローするように見えるためです。 FactoryFaultedイベントハンドラーにも同様の問題がある可能性があります。ところで@Darin、コードの良いビット...

0
PhilMc