async Task Activate(ActorPath path)
{
var system = ClusterActorSystem.Current;
var runtime = new ActorRuntime(system, this);
var prototype = ActorPrototype.Of(path.Type);
actor = Activator.Activate(path.Type, path.Id, runtime);
actor.Initialize(path.Id, runtime, prototype);
await actor.OnActivate();
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
//Creating a new event listener to redirect the traces to a file
ActorEventListener listener = new ActorEventListener("CounterActorApplication");
listener.EnableEvents(ActorEventSource.Current, EventLevel.LogAlways, EventKeywords.All);
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
ActorRuntime.RegisterActorAsync <CounterActorService>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception ex)
{
ActorEventSource.Current.ActorHostInitializationFailed(ex.ToString());
throw;
}
}
public async Task NoActivateMessageFromRuntime()
{
var actorType = typeof(MyActor);
var options = new ActorRuntimeOptions();
options.Actors.RegisterActor <MyActor>();
var runtime = new ActorRuntime(options, loggerFactory, activatorFactory, proxyFactory);
Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture);
var output = new MemoryStream();
await runtime.DispatchWithoutRemotingAsync(actorType.Name, "abc", nameof(MyActor.MyMethod), new MemoryStream(), output);
var text = Encoding.UTF8.GetString(output.ToArray());
Assert.Equal("\"hi\"", text);
Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture);
}
/// <summary>
/// Add an actor implementation to the fabric container
/// </summary>
/// <typeparam name="TActor"></typeparam>
/// <typeparam name="TActorService"></typeparam>
/// <param name="container"></param>
/// <param name="ActorServiceFactory"></param>
/// <returns></returns>
public static IUnityContainer WithActor <TActor, TActorService>(
this IUnityContainer container,
Func <IUnityContainer, StatefulServiceContext, ActorTypeInformation, Func <ActorService, ActorId, TActor>, TActorService> ActorServiceFactory)
where TActor : ActorBase
where TActorService : ActorService
{
//var logger = container.Resolve<ILoggerFactory>().CreateLogger<TActor>();
//logger.LogInformation("Registering Actor {ActorName}", typeof(TActor).Name);
// container = container.IntializeScope();
if (!container.IsRegistered <IActorDeactivationInterception>())
{
container.RegisterType <IActorDeactivationInterception, OnActorDeactivateInterceptor>(new HierarchicalLifetimeManager());
}
container.RegisterType(typeof(TActor), ActorProxyTypeFactory.CreateType <TActor>(), new HierarchicalLifetimeManager());
ActorRuntime.RegisterActorAsync <TActor>((context, actorType) =>
{
try
{
var serviceContainer = container.IntializeScope();
return(ActorServiceFactory(serviceContainer, context, actorType, (service, id) =>
serviceContainer
.IntializeScope()
.RegisterInstance(service.Context.CodePackageActivationContext, new ExternallyControlledLifetimeManager())
.RegisterInstance(service, new ExternallyControlledLifetimeManager())
// .RegisterInstance(service as TActorService, new ExternallyControlledLifetimeManager())
.RegisterInstance(id, new ContainerControlledLifetimeManager()).Resolve <TActor>()));
}
catch (Exception ex)
{
// logger.LogCritical(new EventId(100, "FailedToCreateActorService"), ex, "Failed to create ActorService for {ActorName}", typeof(TActor).Name);
throw;
}
}).GetAwaiter().GetResult();
return(container);
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see http://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <VisualObjectActor>().GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <TestActor>(
(context, actorType) => new TestActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
throw;
}
}
public static void AddActorMethodRoute(this IRouteBuilder routeBuilder)
{
routeBuilder.MapPut("actors/{actorTypeName}/{actorId}/method/{methodName}", async context =>
{
var routeValues = context.Request.RouteValues;
var actorTypeName = (string)routeValues["actorTypeName"];
var actorId = (string)routeValues["actorId"];
var methodName = (string)routeValues["methodName"];
// If Header is present, call is made using Remoting, use Remoting dispatcher.
if (context.Request.Headers.ContainsKey(Constants.RequestHeaderName))
{
var daprActorheader = context.Request.Headers[Constants.RequestHeaderName];
var(header, body) = await ActorRuntime.DispatchWithRemotingAsync(actorTypeName, actorId, methodName, daprActorheader, context.Request.Body);
// Item 1 is header , Item 2 is body
if (header != string.Empty)
{
// exception case
context.Response.Headers.Add(Constants.ErrorResponseHeaderName, header); // add error header
}
await context.Response.Body.WriteAsync(body, 0, body.Length); // add response message body
}
else
{
// write exception info in response.
try
{
await ActorRuntime.DispatchWithoutRemotingAsync(actorTypeName, actorId, methodName, context.Request.Body, context.Response.Body);
}
catch (Exception e)
{
context.Response.Headers.Add("Connection: close", default(string));
context.Response.ContentType = "application/json";
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync(e.ToString());
await context.Response.CompleteAsync();
}
}
});
}
/// <summary>
/// Dies ist der Einstiegspunkt des Diensthostprozesses.
/// </summary>
private static void Main()
{
try
{
// Diese Zeile registriert einen Actordienst zum Hosten Ihrer Akteurklasse bei der Service Fabric-Laufzeit.
// Der Inhalt der Dateien "ServiceManifest.xml" und "ApplicationManifest.xml"
// wird automatisch aufgefüllt, wenn Sie dieses Projekt erstellen.
// Weitere Informationen finden Sie unter https://aka.ms/servicefabricactorsplatform.
ActorRuntime.RegisterActorAsync <NewWorkPiece>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// Este é o ponto de entrada do processo de host de serviço.
/// </summary>
private static void Main()
{
try
{
// Esta linha registra um Serviço de Ator para hospedar sua classe de ator com o tempo de execução do Service Fabric.
// Os conteúdos dos seus arquivos ServiceManifest.xml e ApplicationManifest.xml
// são populados automaticamente ao compilar este projeto.
// Para obter mais informações, consulte https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <HelloWorld> (
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// これは、サービス ホスト プロセスのエントリ ポイントです。
/// </summary>
private static void Main()
{
try
{
// この行は、Service Fabric ランタイムにアクター クラスをホストするアクター サービスを登録します。
// ServiceManifest.xml ファイルと ApplicationManifest.xml ファイルのコンテンツ
// は、このプロジェクトをビルドするときに自動的に設定されます。
//詳細については、https://aka.ms/servicefabricactorsplatform を参照してください
ActorRuntime.RegisterActorAsync <Shape>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// 这是服务主机进程的入口点。
/// </summary>
private static void Main()
{
try
{
// 此行注册了一个角色服务，以使用 Service Fabric 运行时来托管角色类。
// ServiceManifest.xml 和 ApplicationManifest.xml 文件的内容
// 在生成此项目时自动填充。
//有关详细信息，请参阅 https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <ActorBackendService>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// Este es el punto de entrada del proceso de host del servicio.
/// </summary>
private static void Main()
{
try
{
// Esta línea registra un servicio de actor para hospedar la clase de actor en el runtime de Service Fabric.
// El contenido de los archivos ServiceManifest.xml y ApplicationManifest.xml
// se rellena automáticamente cuando se compila el proyecto.
// Para obtener más información, vea https://aka.ms/servicefabricactorsplatform.
ActorRuntime.RegisterActorAsync <GameManagerActor>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// Questo è il punto di ingresso del processo host del servizio.
/// </summary>
private static void Main()
{
try
{
// Questa riga consente di registrare un Servizio Actor per ospitare la classe actor con il runtime di Service Fabric.
// Il contenuto dei file ServiceManifest.xml e ApplicationManifest.xml
// viene popolato automaticamente quando si compila questo progetto.
// Per altre informazioni, vedere http://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <Game>(
(context, actorType) => new ActorService(context, actorType, (a, b) => new Game(a, b))).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
public static Task RegisterActorAsync <TActor>(TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
where TActor : RawStatePersistentActor
{
return(ActorRuntime.RegisterActorAsync <TActor>((context, actorTypeInfo) =>
{
return new ActorService(context, actorTypeInfo, null, (actor, provider) =>
{
var persistent = provider as KvsActorStateProvider;
if (persistent != null)
{
var replica = (KeyValueStoreReplica)ReplicaField.GetValue(provider);
((RawStatePersistentActor)actor).SetReplica(replica);
return new ThrowingActorStateManager();
}
throw new ArgumentException("Event sourced actor must be persistent and use KvsActorStateProvider");
});
}, timeout, cancellationToken));
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static async Task Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
await ActorRuntime.RegisterActorAsync <PlayerSessionActor> (
(context, actorType) => new ActorService(context, actorType));
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
public override Task RegisterAsync(IKernel kernel)
{
return(ActorRuntime.RegisterActorAsync <TActor>((ctx, info) =>
new ActorService(ctx, info, (actorService, actorId) =>
{
try
{
return kernel.Resolve <TActor>(new
{
actorService,
actorId
});
}
catch (Exception e)
{
ActorEventSource.Current.Message("Failed to resolve Actor type {0}.\n{1}", typeof(TActor), e);
throw;
}
})));
}
static void Main()
{
try
{
ActorRuntime.RegisterActorAsync <FriendlyActor>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
ActorRuntime.RegisterActorAsync <PetActor>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
ActorRuntime.RegisterActorAsync <CalculatorActor>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
//Creating a new event listener to redirect the traces to a file
ActorEventListener listener = new ActorEventListener("VisualObjects.ActorService");
listener.EnableEvents(ActorEventSource.Current, EventLevel.LogAlways, EventKeywords.All);
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// For more information, see http://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <VisualObjectActor>().GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <KittyService>(
(context, actorType) => new ActorService(context, actorType,
// Create new kitty service while injecting needed services
(s, i) => new KittyService(s, i, new EtherscanApiClient(new HttpClientRequestFactory()))
)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
new ArgumentException();
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <HelloWorld> (
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <GameActor>(
(context, actorType) => new ActorService(context, actorType, (service, id) =>
new GameActor(service, id, ServiceProxy.Create <IGameManager>(new Uri("fabric:/c4_v3/GameManager"), new ServicePartitionKey(1)))
)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
ActorRuntime.RegisterActorAsync <Gate>(
(context, actorType) => new ActorService(context, actorType, null, null, null, new ActorServiceSettings
{
ActorGarbageCollectionSettings = new ActorGarbageCollectionSettings(120, 60),
ActorConcurrencySettings = new ActorConcurrencySettings
{
LockTimeout = TimeSpan.FromSeconds(10)
}
})).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
e.Log();
throw;
}
}
private static void Main()
{
try
{
ActorRuntime.RegisterActorAsync <DictionaryService>(
(context, actorType) =>
new ActorService(context, actorType,
() =>
new DictionaryService(new AssetPairRepository(), new CountryRepository(),
new MarginalAssetPairRepository(), new MarginalIssuerRepository(),
new MarginalAssetRepository())))
.GetAwaiter()
.GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
TelemetryClient = new TelemetryClient();
}
catch (Exception)
{
// ignored
}
try
{
// Create default garbage collection settings for all the actor types
var actorGarbageCollectionSettings = new ActorGarbageCollectionSettings(300, 60);
// This line registers your actor class with the Fabric Runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see http://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <DeviceActor>(
(context, actorType) => new DeviceActorService(context, actorType, () => new DeviceActor(), null, new ActorServiceSettings
{
ActorGarbageCollectionSettings = actorGarbageCollectionSettings
})).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
TelemetryClient.TrackException(e);
ActorEventSource.Current.ActorHostInitializationFailed(e);
throw;
}
finally
{
TelemetryClient.Flush();
}
}
public async Task TestActorSettingsWithReentrancy()
{
var actorType = typeof(TestActor);
var options = new ActorRuntimeOptions();
options.Actors.RegisterActor <TestActor>();
options.ActorIdleTimeout = TimeSpan.FromSeconds(33);
options.ActorScanInterval = TimeSpan.FromSeconds(44);
options.DrainOngoingCallTimeout = TimeSpan.FromSeconds(55);
options.DrainRebalancedActors = true;
options.ReentrancyConfig.Enabled = true;
options.ReentrancyConfig.MaxStackDepth = 64;
var runtime = new ActorRuntime(options, loggerFactory, activatorFactory, proxyFactory);
Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture);
ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>();
await runtime.SerializeSettingsAndRegisteredTypes(writer);
// read back the serialized json
var array = writer.WrittenSpan.ToArray();
string s = Encoding.UTF8.GetString(array, 0, array.Length);
JsonDocument document = JsonDocument.Parse(s);
JsonElement root = document.RootElement;
// parse out the entities array
JsonElement element = root.GetProperty("entities");
Assert.Equal(1, element.GetArrayLength());
element = root.GetProperty("reentrancy").GetProperty("enabled");
Assert.True(element.GetBoolean());
element = root.GetProperty("reentrancy").GetProperty("maxStackDepth");
Assert.Equal(64, element.GetInt32());
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <DemoActor> (
(context, actorType) =>
{
var service = new ExtendedActorService(context, actorType)
{
// Optional, log the call before the message is handled
BeforeHandleRequestResponseAsync = requestInfo =>
{
ActorEventSource.Current.Message($"BeforeHandleRequestResponseAsync {requestInfo.ActorService} {requestInfo.Method} for actor {requestInfo.ActorId.ToString()}");
return(Task.FromResult <object>(null));
},
// Optional, log the call after the message is handled
AfterHandleRequestResponseAsync = reponseInfo =>
{
ActorEventSource.Current.Message($"AfterHandleRequestResponseAsync {reponseInfo.ActorService} {reponseInfo.Method} for actor {reponseInfo.ActorId.ToString()}");
return(Task.FromResult <object>(null));
},
};
return(service);
}).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <MyActor>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
Console.WriteLine("Actor runtime registration completed");
// Speak with actor a few times. I.e. send messages.
// Create a randomly distributed actor ID
ActorId actorId = ActorId.CreateRandom();
// This only creates a proxy object, it does not activate an actor or invoke any methods yet.
IMyActor myActor = ActorProxy.Create <IMyActor>(actorId, new Uri("fabric:/MyApp/MyActorService"));
// Create the token source.
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken cts = source.Token;
// This will invoke a method on the actor. If an actor with the given ID does not exist, it will
// be activated by this method call.
myActor.SetCountAsync(1, cts);
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
private static void Main()
{
try
{
var container = new Container()
.WithActorFactories();
container.RegisterMany(new [] { typeof(Program).Assembly },
type => type.IsAssignableTo(typeof(IoCEnabledActorBase)));
ActorRuntime.RegisterActorAsync <DeviceSensor>((context, typeInformation) =>
new ActorService(context, typeInformation,
container.ActorFactory <DeviceSensor>
)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
public static void Main(string[] args)
{
try
{
ThreadPool.SetMinThreads(10000, 500);
ServicePointManager.DefaultConnectionLimit = int.MaxValue;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.Expect100Continue = false;
LoggingSource.Initialize(ActorEventSource.Current.Message);
ActorRuntime.RegisterActorAsync <StockTrendPredictionActor>().GetAwaiter().GetResult();
ActorRuntime.RegisterActorAsync <NotificationActor>().GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
// This line registers an Actor Service to host your actor class with the Service Fabric runtime.
// The contents of your ServiceManifest.xml and ApplicationManifest.xml files
// are automatically populated when you build this project.
// For more information, see https://aka.ms/servicefabricactorsplatform
ActorRuntime.RegisterActorAsync <PersonActor>(
(context, actorType) => new PersonActorService(context, actorType)).GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
// TODO: Fix this logging, add option to build ActorOrActorServiceDescription from FabricRuntime?
//FabricRuntime.GetNodeContext().
new ActorLogger(null).ActorHostInitializationFailed(e);
throw;
}
}
/// <summary>
/// This is the entry point of the service host process.
/// </summary>
private static void Main()
{
try
{
//Creating a new event listener to redirect the traces to a file
ActorEventListener listener = new ActorEventListener();
listener.EnableEvents(ActorEventSource.Current, EventLevel.LogAlways, EventKeywords.All);
ActorEventSource.Current.Message("Registering Actor : {0}", "Myactorserv");
ActorRuntime.RegisterActorAsync <Myactorserv>(
(context, actorType) => new ActorService(context, actorType)).GetAwaiter().GetResult();
ActorEventSource.Current.Message("Registered Actor : {0}", "Myactorserv");
Thread.Sleep(Timeout.Infinite);
}
catch (Exception ex)
{
ActorEventSource.Current.ActorHostInitializationFailed(ex.ToString());
throw;
}
}
