public void Stop()
{
try
{
var shutdownEvent = Shutdown;
if (shutdownEvent != null)
{
shutdownEvent(this, EventArgs.Empty);
}
}
catch (Exception ex)
{
ExceptionManager.RegisterException(ex);
}
try
{
OnStop();
}
catch (Exception ex)
{
ExceptionManager.RegisterException(ex);
}
InitializationManager.TeardownAll();
_configuration.Save();
GC.Collect();
_shouldStop = true;
}
public void Start(string[] args)
{
Contract.Requires(args != null);
GC.Collect();
var asmPath = Assembly.GetEntryAssembly().Location;
Contract.Assume(!string.IsNullOrEmpty(asmPath));
_configuration = new ApplicationConfiguration(asmPath);
_configuration.ScanAll();
_configuration.Open();
InitializationManager.InitializeAll();
try
{
OnStart(args);
}
catch (Exception ex)
{
ExceptionManager.RegisterException(ex);
}
_log.Info("{0} initialized.", GetType().Name);
}
static void Main(string[] args)
{
#if !LCG_UI
DemographicModel.Init();
Dashboard.ImportEntryObjects(typeof(DemographicModel));
#else
ResourceManager.Misc.SolutionPath = $"{Directory.GetCurrentDirectory()}/../../../..";
InitializationManager.InitializeAll();
Dashboard.ImportEntryObjects(typeof(ResourceManager));
#endif
Program world = new Program();
world.execute("show");
while (true)
{
var me = Console.ReadLine();
/* Switch on the power line
* Remember to put on
* PROTECTION
* Lay down your pieces
* And let's begin
* OBJECT CREATION
* Fill in my data parameters
* INITIALIZATION
* Set up our new world
* And let's begin the
* SIMULATION */
world.execute(me);
}
}
public void ShouldCallInitializationManagerOnConstruction()
{
InitializationManager initializationManager = Substitute.For <InitializationManager>(new TestInitializationActionDiscoverer(), new InitializationActionExecutor());
TestApplication application = new CustomTestApplication(initializationManager);
initializationManager.Received().Initialize(0, Arg.Is <TestApplicationInitializationContext>(context => context.Application == application));
}
public FactsBase()
{
_jobState = new Mock <IRevalidationJobStateService>();
_packageState = new Mock <IPackageRevalidationStateService>();
_packageFinder = new Mock <IPackageFinder>();
_scopeFactory = new Mock <IServiceScopeFactory>();
var scope = new Mock <IServiceScope>();
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(p => p.GetService(typeof(IRevalidationJobStateService))).Returns(_jobState.Object);
serviceProvider.Setup(p => p.GetService(typeof(IPackageRevalidationStateService))).Returns(_packageState.Object);
serviceProvider.Setup(p => p.GetService(typeof(IPackageFinder))).Returns(_packageFinder.Object);
serviceProvider.Setup(p => p.GetService(typeof(IServiceScopeFactory))).Returns(_scopeFactory.Object);
scope.Setup(s => s.ServiceProvider).Returns(serviceProvider.Object);
_scopeFactory.Setup(s => s.CreateScope()).Returns(scope.Object);
_config = new InitializationConfiguration();
_target = new InitializationManager(
_jobState.Object,
_packageState.Object,
_packageFinder.Object,
_scopeFactory.Object,
_config,
Mock.Of <ILogger <InitializationManager> >());
}
void Awake()
{
if (instance != null)
{
Debug.LogError("More than one InitializationManager in scene !"); return;
}
instance = this;
}
/// <summary>
/// Initializes a new instance of the <see cref="RequestManager"/> class.
/// </summary>
/// <param name="initializationManager">The initialization action discoverer.</param>
protected RequestManager(InitializationManager initializationManager)
{
if (initializationManager == null)
{
throw new ArgumentNullException("initializationManager");
}
this.initializationManager = initializationManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="LiveTestTest"/> class.
/// </summary>
public LiveTestTest()
{
this.testApplication = Substitute.For <TestApplication>();
this.initializationManager = Substitute.For <InitializationManager>(Substitute.For <InitializationActionDiscoverer>(), Substitute.For <InitializationActionExecutor>());
LiveTestBase.TestApplicationManager.StartApplication(Arg.Is <TestApplicationHost>(host => (host.ApplicationId == "Sitecore.LiveTesting.Default") && (host.VirtualPath == "/") && (host.PhysicalPath == "..\\Website"))).Returns(this.testApplication);
this.realTest = new TestWithCustomInstantiation(this.initializationManager);
}
public void ShouldCallInitializationManagerOnStop()
{
InitializationManager initializationManager = Substitute.For <InitializationManager>(new TestInitializationActionDiscoverer(), new InitializationActionExecutor());
TestApplication application = new CustomTestApplication(initializationManager);
((IRegisteredObject)application).Stop(false);
initializationManager.Received().Cleanup(0, Arg.Is <TestApplicationInitializationContext>(context => context.Application == application));
}
public CodeGeneratorManager(
TypeAnalyzer typeAnalyzer,
InitializationManager initializationManager,
ArrayCodeGenerator arrayCodeGenerator,
VariableDeclarationManager variableDeclarationType)
{
_typeAnalyzer = typeAnalyzer;
_initializationManager = initializationManager;
_arrayCodeGenerator = arrayCodeGenerator;
_variableDeclarationType = variableDeclarationType;
}
public override void Initialize()
{
try
{
base.Initialize();
ConsoleInterface = new AuthConsole();
ConsoleBase.SetTitle($"#Stump Authentification Server - {Version}");
logger.Info("Initializing Database...");
DBAccessor = new DatabaseAccessor(DatabaseConfiguration);
DBAccessor.RegisterMappingAssembly(Assembly.GetExecutingAssembly());
InitializationManager.Initialize(InitializationPass.Database);
DBAccessor.Initialize();
logger.Info("Opening Database...");
DBAccessor.OpenConnection();
DataManager.DefaultDatabase = DBAccessor.Database;
DataManagerAllocator.Assembly = Assembly.GetExecutingAssembly();
logger.Info("Register Messages...");
MessageReceiver.Initialize();
ProtocolTypeManager.Initialize();
logger.Info("Register Packets Handlers...");
HandlerManager = AuthPacketHandler.Instance;
HandlerManager.RegisterAll(Assembly.GetExecutingAssembly());
logger.Info("Register Commands...");
CommandManager.RegisterAll(Assembly.GetExecutingAssembly());
logger.Info("Start World Servers Manager");
WorldServerManager.Instance.Initialize();
logger.Info("Initialize Account Manager");
AccountManager.Instance.Initialize();
logger.Info("Initialize IPC Server..");
IpcHost = new IPCHost(IpcAddress, IpcPort);
InitializationManager.InitializeAll();
IsInitialized = true;
if (Environment.GetCommandLineArgs().Contains("-maintenance"))
{
m_maintenanceMode = true;
}
}
catch (Exception ex)
{
HandleCrashException(ex);
Shutdown();
}
}
private Graph reducedVisibilityGraph = null; // store the reduced visibility graph of map containing obstacles
// Awake is called before all classes
void Awake()
{
initManager = this;
obstacleGameObjects = generateObstacles(obstaclePrefab); // randomly generate obstacles
reducedVisibilityGraph = generateRVgraph(mapBoundaryPoints, obstacleGameObjects); // generate Reduced Visibility graph based on the obstacles and map boundary
drawReducedVisibilityGraph(reducedVisibilityGraph); // draw the Reduced Visibility graph
placeVerticesObjects(reducedVisibilityGraph, vertexPrefab); // place vertices game object
changeObstaclesSize(obstacleGameObjects, new Vector3(shrinkObstacleScale, 0, shrinkObstacleScale - 0.1f)); // decrease the obstacle size, prevent agent colliding with obstacles when moving along a path which is around an obstacle
}
private void Start()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
InitializeManagers();
}
public async Task <InitializationResult> InitializeAsync(string authTkn, Guid licenseServiceID, string socialReason, string RFC,
PayrollCompanyConfiguration payrollCompanyConfiguration, EmployerRegistration employerRegistration)
{
var mgr = new InitializationManager();
return(await mgr.InitializeAsync(new InitializationParams
{
AuthTkn = authTkn,
LicenseServiceID = licenseServiceID,
SocialReason = socialReason,
RFC = RFC,
PayrollCompanyConfiguration = payrollCompanyConfiguration,
EmployerRegistration = employerRegistration
}));
}
public void Test()
{
var testClass = new TestClass();
IInitializationStrategy strategy = new InitStrategy();
var initializationManager = new InitializationManager();
initializationManager.AddStrategy <TestClass>(strategy);
var task = initializationManager.InitViewModel(testClass);
task.Wait();
Assert.That(testClass.TestOne, Is.EqualTo(777));
Assert.That(testClass.TestTwo, Is.EqualTo("777"));
Assert.That(testClass.TestThree, Is.Not.Null);
}
#pragma warning restore 0649
void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(gameObject);
InitState = InitializationState.Initializing;
_instantiatedManagers = new List <Manager>();
SceneManager.sceneLoaded += OnSceneLoaded;
SceneManager.sceneUnloaded += OnSceneUnloaded;
}
else
{
Destroy(gameObject);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerRequest"/> class.
/// </summary>
/// <param name="initializationManager">The initialization Manager.</param>
/// <param name="context">The request initialization context.</param>
/// <param name="writer">The writer.</param>
internal WorkerRequest(InitializationManager initializationManager, RequestInitializationContext context, TextWriter writer) : base(context.Request.Path, context.Request.QueryString, writer)
{
if (initializationManager == null)
{
throw new ArgumentNullException("initializationManager");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
this.connectionId = Interlocked.Increment(ref connectionCount);
this.initializationManager = initializationManager;
this.context = context;
}
/// <summary>
/// Cross application initialization of components.
/// </summary>
static void Initialize()
{
ShapeManager.Init();
InitializationManager.RestoreReplacementChars();
var zForm = new Form();
var zGraphics = zForm.CreateGraphics();
try
{
CardMakerInstance.ApplicationDPI = zGraphics.DpiX;
}
finally
{
zGraphics.Dispose();
}
}
public void ShouldExecuteInitializersInReverseOrderOnCleanup()
{
const int MethodCallId = 123;
this.manager = new InitializationManager(this.actionDiscoverer, this.actionExecutor, new Dictionary <int, IList <InitializationAction> > {
{ MethodCallId, new[] { new InitializationAction("Action1"), new InitializationAction("Action2") } }
});
this.manager.Cleanup(MethodCallId, null);
Received.InOrder(
() =>
{
this.actionExecutor.ExecuteCleanupForAction(Arg.Is <InitializationAction>(action => action.Id == "Action2"));
this.actionExecutor.ExecuteCleanupForAction(Arg.Is <InitializationAction>(action => action.Id == "Action1"));
});
}
/// <summary>
/// Get Object from S3 Bucket
/// </summary>
public void GetObject(string filename, string S3BucketName)
{
InitializationManager.DownloadCount++;
Client.GetObjectAsync(S3BucketName, filename, (responseObj) =>
{
var response = responseObj.Response;
if (response.ResponseStream != null)
{
//Debug.Log("response " + response.ResponseStream);
filename = S3BucketName + "/" + filename;
UIB_FileManager.WriteFileFromResponse(response, filename);
Directory.SetLastAccessTime(UIB_PlatformManager.persistentDataPath, DateTime.Now);
InitializationManager.DownloadCount--;
InitializationManager.ReloadAssetBundle(filename);
}
});
}
public static CodeGeneratorManager Create(Dictionary <string, IReadOnlyList <string> > readonlyObjects, bool useConcreteType)
{
var argumentListManager = new ArgumentListManager(readonlyObjects, new ConcreteTypeAnalyzer(), new DumpStackToCSharpCode.ObjectInitializationGeneration.Constructor.ConstructorsManager());
var initializationManager = new InitializationManager(new TypeAnalyzer(),
new PrimitiveExpressionGenerator(),
new DictionaryExpressionGenerator(),
new ComplexTypeInitializationGenerator(new TypeAnalyzer()),
new ArrayInitializationGenerator(new TypeAnalyzer()),
new AssignmentExpressionGenerator(),
argumentListManager,
new EnumExpressionGenerator(),
new ImmutableInitializationGenerator(),
new DumpStackToCSharpCode.ObjectInitializationGeneration.Expression.ObjectInicializationExpressionGenerator(new TypeAnalyzer()),
new DumpStackToCSharpCode.ObjectInitializationGeneration.Initialization.GuidInitializationManager(new ComplexTypeInitializationGenerator(new TypeAnalyzer()), new PrimitiveExpressionGenerator()),
new DumpStackToCSharpCode.ObjectInitializationGeneration.Initialization.RegexInitializationManager(new ComplexTypeInitializationGenerator(new TypeAnalyzer()), new PrimitiveExpressionGenerator()),
new DumpStackToCSharpCode.ObjectInitializationGeneration.Expression.PrimitiveNullableExpressionGenerator(new DumpStackToCSharpCode.ObjectInitializationGeneration.Expression.ObjectInicializationExpressionGenerator(new TypeAnalyzer())));
return(new CodeGeneratorManager(new TypeAnalyzer(), initializationManager, new ArrayCodeGenerator(new VariableDeclarationManager(useConcreteType)), new VariableDeclarationManager(useConcreteType)));
}
/// <summary>
/// Initializes a new instance of the <see cref="TestApplication"/> class.
/// </summary>
/// <param name="initializationManager">The initialization manager.</param>
protected TestApplication(InitializationManager initializationManager)
{
if (initializationManager == null)
{
throw new ArgumentNullException("initializationManager");
}
if (HostingEnvironment.IsHosted)
{
HostingEnvironment.RegisterObject(this);
// INFO: workaround to avoid AppDomainUnloadedException because of Sitecore agents
object hostingEnvironment = typeof(HostingEnvironment).GetField("_theHostingEnvironment", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
EventHandler eventHandler = (EventHandler)typeof(HostingEnvironment).GetField("_onAppDomainUnload", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(hostingEnvironment);
Thread.GetDomain().DomainUnload -= eventHandler;
}
this.initializationManager = initializationManager;
this.initializationManager.Initialize(0, new TestApplicationInitializationContext(this));
}
public override void Initialize()
{
base.Initialize();
ConsoleInterface = new WorldConsole();
VirtualConsoleInterface = new WorldVirtualConsole();
ConsoleBase.SetTitle($"#Stump World Server - {Version} : {ServerInformation.Name}");
logger.Info("Initializing Database...");
DBAccessor = new DatabaseAccessor(DatabaseConfiguration);
DBAccessor.RegisterMappingAssembly(Assembly.GetExecutingAssembly());
foreach (var plugin in PluginManager.Instance.GetPlugins())
{
DBAccessor.RegisterMappingAssembly(plugin.PluginAssembly);
}
InitializationManager.Initialize(InitializationPass.Database);
DBAccessor.Initialize();
logger.Info("Opening Database...");
DBAccessor.OpenConnection();
DataManager.DefaultDatabase = DBAccessor.Database;
DataManagerAllocator.Assembly = Assembly.GetExecutingAssembly();
DBAccessor.Database.ExecutingCommand += OnExecutingDBCommand;
logger.Info("Register Messages...");
MessageReceiver.Initialize();
ProtocolTypeManager.Initialize();
logger.Info("Register Packet Handlers...");
HandlerManager = WorldPacketHandler.Instance;
HandlerManager.RegisterAll(Assembly.GetExecutingAssembly());
logger.Info("Register Commands...");
CommandManager.RegisterAll(Assembly.GetExecutingAssembly());
InitializationManager.InitializeAll();
CommandManager.LoadOrCreateCommandsInfo(CommandsInfoFilePath);
IsInitialized = true;
}
private void illegalFilenameCharacterReplacementToolStripMenuItem_Click(object sender, EventArgs e)
{
var zQuery = new QueryPanelDialog("Illegal File Name Character Replacement", 350, false);
zQuery.SetIcon(Properties.Resources.CardMakerIcon);
var arrayBadChars = FilenameTranslator.DISALLOWED_FILE_CHARS_ARRAY;
var arrayReplacementChars = CardMakerSettings.IniManager.GetValue(IniSettings.ReplacementChars, string.Empty).Split(new char[] { CardMakerConstants.CHAR_FILE_SPLIT });
if (arrayReplacementChars.Length == FilenameTranslator.DISALLOWED_FILE_CHARS_ARRAY.Length)
{
// from ini
for (int nIdx = 0; nIdx < arrayBadChars.Length; nIdx++)
{
zQuery.AddTextBox(arrayBadChars[nIdx].ToString(CultureInfo.InvariantCulture), arrayReplacementChars[nIdx], false, nIdx.ToString(CultureInfo.InvariantCulture));
}
}
else
{
// default
for (int nIdx = 0; nIdx < arrayBadChars.Length; nIdx++)
{
zQuery.AddTextBox(arrayBadChars[nIdx].ToString(CultureInfo.InvariantCulture), string.Empty, false, nIdx.ToString(CultureInfo.InvariantCulture));
}
}
if (DialogResult.OK == zQuery.ShowDialog(this))
{
var zBuilder = new StringBuilder();
for (int nIdx = 0; nIdx < arrayBadChars.Length; nIdx++)
{
zBuilder.Append(zQuery.GetString(nIdx.ToString(CultureInfo.InvariantCulture)) + CardMakerConstants.CHAR_FILE_SPLIT);
}
zBuilder.Remove(zBuilder.Length - 1, 1); // remove last char
CardMakerSettings.IniManager.SetValue(IniSettings.ReplacementChars, zBuilder.ToString());
InitializationManager.RestoreReplacementChars();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Test"/> class.
/// </summary>
/// <param name="initializationManager">The initialization manager.</param>
public Test(InitializationManager initializationManager) : base(initializationManager)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TestWithCustomInstantiation"/> class.
/// </summary>
/// <param name="initializationManager">The initialization manager.</param>
public TestWithCustomInstantiation(InitializationManager initializationManager) : base(initializationManager)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="LiveTestBase"/> class.
/// </summary>
/// <param name="initializationManager">The initialization manager.</param>
public LiveTestBase(InitializationManager initializationManager) : base(initializationManager)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="LiveTest"/> class.
/// </summary>
/// <param name="initializationManager">The initialization manager.</param>
protected LiveTest(InitializationManager initializationManager)
{
this.initializationManager = initializationManager;
}
private void AppStartup(object sender, StartupEventArgs e)
{
var userContextRW = new CNCLibUserContext();
ICNCLibUserContext userContext = userContextRW;
var localizationCollector = new LocalizationCollector();
var moduleInit = new InitializationManager();
moduleInit.Add(new Framework.Tools.ModuleInitializer());
moduleInit.Add(new Framework.Arduino.SerialCommunication.ModuleInitializer());
moduleInit.Add(new Framework.Logic.ModuleInitializer()
{
MapperConfiguration =
new MapperConfiguration(
cfg =>
{
cfg.AddProfile <WpfAutoMapperProfile>();
cfg.AddProfile <GCodeGUIAutoMapperProfile>();
})
});
moduleInit.Add(new CNCLib.Logic.Client.ModuleInitializer());
moduleInit.Add(new CNCLib.WpfClient.ModuleInitializer());
moduleInit.Add(new CNCLib.Service.WebAPI.ModuleInitializer()
{
ConfigureHttpClient = httpClient =>
{
HttpClientHelper.PrepareHttpClient(httpClient, @"https://cnclib.azurewebsites.net");
httpClient.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue(
"Basic", Base64Helper.StringToBase64($"{userContextRW.UserName}:{userContextRW.Password}"));
}
});
GlobalDiagnosticsContext.Set("logDir", $"{Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)}/CNCLib.Web/logs");
_logger.Info(@"Starting ...");
FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)));
AppService.ServiceCollection = new ServiceCollection();
AppService.ServiceCollection
.AddTransient <ILoggerFactory, LoggerFactory>()
.AddTransient(typeof(ILogger <>), typeof(Logger <>))
.AddSingleton(userContext);
moduleInit.Initialize(AppService.ServiceCollection, localizationCollector);
AppService.BuildServiceProvider();
// Open WebAPI Connection
//
bool ok = Task.Run(
async() =>
{
try
{
await userContextRW.InitUserContext(userContextRW.UserName);
using (var scope = AppService.ServiceProvider.CreateScope())
{
var controller = scope.ServiceProvider.GetRequiredService <IMachineService>();
var m = await controller.Get(1000000);
return(true);
}
}
catch (Exception ex)
{
MessageBox.Show($"Cannot connect to WebAPI: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
Current.Shutdown();
return(false);
}
}).ConfigureAwait(true).GetAwaiter().GetResult();
}
public virtual void Initialize()
{
InstanceAsBase = this;
Initializing = true;
Version = ((AssemblyInformationalVersionAttribute)System.Reflection.Assembly.GetExecutingAssembly()
.GetCustomAttributes <AssemblyInformationalVersionAttribute>().FirstOrDefault())
.InformationalVersion;
/* Initialize Logger */
NLogHelper.DefineLogProfile(true, true);
NLogHelper.EnableLogging();
logger = LogManager.GetCurrentClassLogger();
if (!Debugger.IsAttached)
{
AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
Contract.ContractFailed += OnContractFailed;
}
else
{
logger.Warn("Exceptions not handled cause Debugger is attatched");
}
PreLoadReferences(Assembly.GetCallingAssembly());
LoadedAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToDictionary(entry => entry.GetName().Name);
AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
if (Environment.GetCommandLineArgs().Contains("-config"))
{
UpdateConfigFiles();
}
ConsoleBase.DrawAsciiLogo();
Console.WriteLine();
InitializeGarbageCollector();
logger.Info("Initializing Configuration...");
/* Initialize Config File */
Config = new XmlConfig(ConfigFilePath);
Config.AddAssemblies(LoadedAssemblies.Values.ToArray());
if (!File.Exists(ConfigFilePath))
{
Config.Create();
logger.Info("Config file created");
}
else
{
Config.Load();
}
logger.Info("Initialize Task Pool");
IOTaskPool = new BenchmarkedTaskPool(IOTaskInterval, "IO Task Pool");
CommandManager = CommandManager.Instance;
CommandManager.RegisterAll(Assembly.GetExecutingAssembly());
logger.Info("Initializing Network Interfaces...");
ClientManager = ClientManager.Instance;
ClientManager.Initialize(CreateClient);
if (Settings.InactivityDisconnectionTime.HasValue)
{
IOTaskPool.CallPeriodically(Settings.InactivityDisconnectionTime.Value / 4 * 1000, DisconnectAfkClient);
}
ClientManager.ClientConnected += OnClientConnected;
ClientManager.ClientDisconnected += OnClientDisconnected;
logger.Info("Register Plugins...");
// the plugins add them themself to the initializer
InitializationManager = InitializationManager.Instance;
InitializationManager.AddAssemblies(AppDomain.CurrentDomain.GetAssemblies());
PluginManager = PluginManager.Instance;
PluginManager.PluginAdded += OnPluginAdded;
PluginManager.PluginRemoved += OnPluginRemoved;
logger.Info("Loading Plugins...");
PluginManager.Instance.LoadAllPlugins();
if (IsExceptionLoggerEnabled)
{
ExceptionLogger = new RavenClient(ExceptionLoggerDSN);
ExceptionLogger.Release = Version;
#if DEBUG
ExceptionLogger.Environment = "DEBUG";
#else
ExceptionLogger.Environment = "RELEASE";
#endif
}
}
