C# Ice.ice_isA方法代码示例

 public static DHTNodePrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
 {
     if(b == null)
     {
         return null;
     }
     DHTNodePrx r = b as DHTNodePrx;
     if((r == null) && b.ice_isA("::IDHT::DHTNode", ctx))
     {
         DHTNodePrxHelper h = new DHTNodePrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static UserManagementPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     UserManagementPrx r = b as UserManagementPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         UserManagementPrxHelper h = new UserManagementPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static AppServicePrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     AppServicePrx r = b as AppServicePrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         AppServicePrxHelper h = new AppServicePrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static MESLinkPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     MESLinkPrx r = b as MESLinkPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         MESLinkPrxHelper h = new MESLinkPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static sys_role_permission_rpcPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
 {
     if(b == null)
     {
         return null;
     }
     sys_role_permission_rpcPrx r = b as sys_role_permission_rpcPrx;
     if((r == null) && b.ice_isA(ice_staticId(), ctx))
     {
         sys_role_permission_rpcPrxHelper h = new sys_role_permission_rpcPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static BufferTransferPrx checkedCast(Ice.ObjectPrx b, Ice.Context ctx)
 {
     if(b == null)
     {
         return null;
     }
     if(b is BufferTransferPrx)
     {
         return (BufferTransferPrx)b;
     }
     if(b.ice_isA("::InfoDTV::Multiplexer::Dynamic::Provider::BufferTransfer", ctx))
     {
         BufferTransferPrxHelper h = new BufferTransferPrxHelper();
         h.copyFrom__(b);
         return h;
     }
     return null;
 }

 /// <summary>
 /// Determines whether specified functions object (<c>functionsPrx</c>)
 /// is satisfy specified box type (<c>boxType</c>) i.e. whether
 /// functions object implements required functions and its box module
 /// has required sockets.
 /// </summary>
 /// <param name="boxType">Required type of the box.</param>
 /// <param name="functionsPrx">The functions object`s proxy.</param>
 /// <param name="sockets">The sockets of box module to which the functions object belongs to.</param>
 /// <returns>
 /// <c>true</c> if the specified functions object 
 /// <see cref="M:Ice.ObjectPrx.ice_isA(System.String)">
 /// implements required functions</see> and and its box module 
 /// <see cref="M:Ferda.Modules.BoxModuleI.hasSockets(Ferda.Modules.NeededSocket[],Ferda.Modules.SocketInfo[])">
 /// has required sockets</see>.
 /// </returns>
 private static bool hasBoxType(BoxType boxType, Ice.ObjectPrx functionsPrx, SocketInfo[] sockets)
 {
     return functionsPrx.ice_isA(boxType.functionIceId) &&
         hasSockets(boxType.neededSockets, sockets);
 }

 public static CallbackReceiverPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     CallbackReceiverPrx r = b as CallbackReceiverPrx;
     if((r == null) && b.ice_isA("::KeeICE::KPlib::CallbackReceiver"))
     {
         CallbackReceiverPrxHelper h = new CallbackReceiverPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static SessionPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     SessionPrx r = b as SessionPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         SessionPrxHelper h = new SessionPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static VSClientPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     VSClientPrx r = b as VSClientPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         VSClientPrxHelper h = new VSClientPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static RepoApiPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
 {
     if(b == null)
     {
         return null;
     }
     RepoApiPrx r = b as RepoApiPrx;
     if((r == null) && b.ice_isA("::RepoIce::RepoApi", ctx))
     {
         RepoApiPrxHelper h = new RepoApiPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static MetaPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     MetaPrx r = b as MetaPrx;
     if((r == null) && b.ice_isA("::Murmur::Meta"))
     {
         MetaPrxHelper h = new MetaPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static CertSignerPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     CertSignerPrx r = b as CertSignerPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         CertSignerPrxHelper h = new CertSignerPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static BaseToBotPrx checkedCast(Ice.ObjectPrx b)
 {
     if(b == null)
     {
         return null;
     }
     BaseToBotPrx r = b as BaseToBotPrx;
     if((r == null) && b.ice_isA(ice_staticId()))
     {
         BaseToBotPrxHelper h = new BaseToBotPrxHelper();
         h.copyFrom__(b);
         r = h;
     }
     return r;
 }

 public static DispatchStatus ice_isA___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
 {
     IceInternal.BasicStream is__ = inS__.startReadParams();
     string __id = is__.readString();
     inS__.endReadParams();
     bool __ret = __obj.ice_isA(__id, __current);
     IceInternal.BasicStream os__ = inS__.startWriteParams__(FormatType.DefaultFormat);
     os__.writeBool(__ret);
     inS__.endWriteParams__(true);
     return DispatchStatus.DispatchOK;
 }