C# ActorSystem.AsInstanceOf方法代码示例

        public RemoteDeploySpec()
            : base(@"
            akka {
                loglevel = INFO 
                log-dead-letters-during-shutdown = false
              //  actor.provider = ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""
                remote.helios.tcp = {
                    hostname = localhost
                    port = 0
                }

                actor.deployment {
                  /router1 {
                    router = round-robin-pool
                    nr-of-instances = 3
                  }
                  /router2 {
                    router = round-robin-pool
                    nr-of-instances = 3
                  }
                  /router3 {
                    router = round-robin-pool
                    nr-of-instances = 0
                  }
                }
            }
")
        {
            _remoteSystem = ActorSystem.Create("RemoteSystem", Sys.Settings.Config);
            _remoteAddress = _remoteSystem.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
            var remoteAddressUid = AddressUidExtension.Uid(_remoteSystem);


        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ConsistentHashingRoutingLogic"/> class.
 /// </summary>
 /// <param name="system">The actor system that owns the router with this logic.</param>
 /// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring.</param>
 /// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
 public ConsistentHashingRoutingLogic(ActorSystem system, int virtualNodesFactor,
     ConsistentHashMapping hashMapping)
 {
     _system = system;
     _log = new Lazy<ILoggingAdapter>(() => Logging.GetLogger(_system, this), true);
     _hashMapping = hashMapping;
     _selfAddress = system.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
     _vnodes = virtualNodesFactor == 0 ? system.Settings.DefaultVirtualNodesFactor : virtualNodesFactor;
 }

        protected MultiNodeSpec(
            RoleName myself,
            ActorSystem system,
            ImmutableList<RoleName> roles,
            Func<RoleName, ImmutableList<string>> deployments)
            : base(new XunitAssertions(), system)
        {
            _myself = myself;
            _log = Logging.GetLogger(Sys, this);
            _roles = roles;
            _deployments = deployments;
            var node = new IPEndPoint(Dns.GetHostAddresses(ServerName)[0], ServerPort);
            _controllerAddr = node;

            AttachConductor(new TestConductor(system));

            _replacements = _roles.ToImmutableDictionary(r => r, r => new Replacement("@" + r.Name + "@", r, this));

            InjectDeployments(system, myself);

            _myAddress = system.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;

            Log.Info("Role [{0}] started with address [{1}]", myself.Name, _myAddress);
            MultiNodeSpecBeforeAll();
        }

 protected void InjectDeployments(ActorSystem system, RoleName role)
 {
     var deployer = system.AsInstanceOf<ExtendedActorSystem>().Provider.Deployer;
     foreach (var str in _deployments(role))
     {
         var deployString = _replacements.Values.Aggregate(str, (@base, r) =>
         {
             var indexOf = @base.IndexOf(r.Tag, StringComparison.Ordinal);
             if (indexOf == -1) return @base;
             string replaceWith;
             try
             {
                 replaceWith = r.Addr;
             }
             catch (Exception e)
             {
                 // might happen if all test cases are ignored (excluded) and
                 // controller node is finished/exited before r.addr is run
                 // on the other nodes
                 var unresolved = "akka://unresolved-replacement-" + r.Role.Name;
                 Log.Warning(unresolved + " due to: {0}", e.ToString());
                 replaceWith = unresolved;
             }
             return @base.Replace(r.Tag, replaceWith);
         });
         foreach (var pair in ConfigurationFactory.ParseString(deployString).AsEnumerable())
         {
             if (pair.Value.IsObject())
             {
                 var deploy =
                     deployer.ParseConfig(pair.Key, new Config(new HoconRoot(pair.Value)));
                 deployer.SetDeploy(deploy);
             }
             else
             {
                 throw new ArgumentException(String.Format("key {0} must map to deployment section, not simple value {1}",
                     pair.Key, pair.Value));
             }
         }
     }
 }