GetExecutingAssembly() private method

private GetExecutingAssembly ( ) : Assembly
return Assembly
Esempio n. 1
0
            public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object aMethodInfo)
            {
                var allTemplates = Assembly.GetExecutingAssembly().GetTypes();

                con.WriteLine("---------------------------------");
                foreach (var template in allTemplates)
                {
                    if (!template.IsClass || typeof(sys.MulticastDelegate).IsAssignableFrom(template.BaseType) || template.IsInterface || template.Name.ToLower().Contains("<") || template.Name.ToLower().Contains("boot") || template.Name.ToLower().Contains("gc") || template.Name.ToLower().Contains("plug") || template.Name.ToLower().Contains("asm"))
                    {
                        continue;
                    }
                    con.WriteLine(template.Name);
                    foreach (var variable in template.GetFields((BindingFlags)int.MaxValue))// BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy))
                    {
                        if (variable.FieldType.IsClass)
                        {
                            con.WriteLine("   Clas " + variable.Name);
                        }
                        else
                        {
                            con.WriteLine("   Elem " + variable.Name);
                        }
                    }
                }
                con.WriteLine("---------------------------------");
            }
Esempio n. 2
0
 /// <summary>
 /// 製品名文字列を取得
 /// </summary>
 /// <returns>製品名文字列</returns>
 public static string GetProductString()
 {
     return
         ((Attribute.GetCustomAttribute
               (SRA.GetExecutingAssembly()
               , typeof(AssemblyProductAttribute)
               ) as AssemblyProductAttribute
           ).Product);
 }
Esempio n. 3
0
 /// <summary>
 /// 権利表示文字列を取得
 /// </summary>
 /// <returns>権利表示文字列</returns>
 public static string GetCopyrightString()
 {
     return
         ((Attribute.GetCustomAttribute
               (SRA.GetExecutingAssembly()
               , typeof(AssemblyCopyrightAttribute)
               ) as AssemblyCopyrightAttribute
           ).Copyright);
 }
Esempio n. 4
0
 /// <summary>
 /// 説明文字列を取得
 /// </summary>
 /// <returns>説明文字列</returns>
 public static string GetDescriptionString()
 {
     return
         ((Attribute.GetCustomAttribute
               (SRA.GetExecutingAssembly()
               , typeof(AssemblyDescriptionAttribute)
               ) as AssemblyDescriptionAttribute
           ).Description);
 }
Esempio n. 5
0
 /// <summary>
 /// タイトル文字列を取得
 /// </summary>
 /// <returns>タイトル文字列</returns>
 public static string GetTitleString()
 {
     return
         ((Attribute.GetCustomAttribute
               (SRA.GetExecutingAssembly()
               , typeof(AssemblyTitleAttribute)
               ) as AssemblyTitleAttribute
           ).Title);
 }
Esempio n. 6
0
        /// <summary>
        /// Gets the real assembly name of the class provided.
        /// </summary>
        /// <typeparam name="T">The type to get the assembly name from.</typeparam>
        /// <returns>The name of the assembly title, if available. Otherwise, the executing assembly name.</returns>
        public static string GetAssemblyName <T>()
        {
            // get real assembly name, if possible.
            object[] attribs = typeof(T).Assembly.GetCustomAttributes(typeof(AssemblyTitleAttribute), false);
            if (attribs.Length > 0)
            {
                var titleAttribute = (AssemblyTitleAttribute)attribs[0];
                if (titleAttribute.Title.Length > 0)
                {
                    return(titleAttribute.Title);
                }
            }

            // couldn't get the title attribute, use executing assembly name.
            return(SRAssembly.GetExecutingAssembly().GetName().Name);
        }
Esempio n. 7
0
        public static void CreateTileSet()
        {
            Type     tileType    = typeof(Tile);
            Assembly assembly    = Assembly.GetExecutingAssembly();
            var      tileClasses = assembly.GetTypes().Where(t => t.IsSubclassOf(tileType));

            foreach (Type tile in tileClasses)
            {
                Tile tileObject = Activator.CreateInstance(tile) as Tile;
                tile.InvokeMember(
                    "SetDefaults",
                    BindingFlags.InvokeMethod,
                    null,
                    tileObject,
                    null
                    );
            }
        }
Esempio n. 8
0
        public static XmlDocument LoadFileSumData()
        {
            using (
                var stream =
                    Assembly.GetExecutingAssembly()
                    .GetManifestResourceStream("DNN.Modules.SecurityAnalyzer.Resources.sums.resources"))
            {
                if (stream != null)
                {
                    var xmlDocument = new XmlDocument();
                    xmlDocument.Load(stream);

                    return(xmlDocument);
                }
                else
                {
                    return(null);
                }
            }
        }
Esempio n. 9
0
        CreateCodeGroup(SecurityElement el)
        {
            if (el == null || !el.Tag.Equals("CodeGroup"))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongElementType"), "<CodeGroup>"));
            }
            Contract.EndContractBlock();

            String className;
            int    classNameLength;
            int    classNameStart;

            if (!ParseElementForObjectCreation(el,
                                               BuiltInCodeGroup,
                                               out className,
                                               out classNameStart,
                                               out classNameLength))
            {
                goto USEREFLECTION;
            }

            switch (classNameLength)
            {
            case 12:
                // NetCodeGroup
                if (String.Compare(className, classNameStart, "NetCodeGroup", 0, classNameLength, StringComparison.Ordinal) == 0)
                {
                    return(new NetCodeGroup());
                }
                else
                {
                    goto USEREFLECTION;
                }

            case 13:
                // FileCodeGroup
                if (String.Compare(className, classNameStart, "FileCodeGroup", 0, classNameLength, StringComparison.Ordinal) == 0)
                {
                    return(new FileCodeGroup());
                }
                else
                {
                    goto USEREFLECTION;
                }

            case 14:
                // UnionCodeGroup
                if (String.Compare(className, classNameStart, "UnionCodeGroup", 0, classNameLength, StringComparison.Ordinal) == 0)
                {
                    return(new UnionCodeGroup());
                }
                else
                {
                    goto USEREFLECTION;
                }

            case 19:
                // FirstMatchCodeGroup
                if (String.Compare(className, classNameStart, "FirstMatchCodeGroup", 0, classNameLength, StringComparison.Ordinal) == 0)
                {
                    return(new FirstMatchCodeGroup());
                }
                else
                {
                    goto USEREFLECTION;
                }

            default:
                goto USEREFLECTION;
            }

USEREFLECTION:
            Type groupClass = null;
            CodeGroup group = null;

            new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Assert();
            groupClass = GetClassFromElement(el, true);
            if (groupClass == null)
            {
                return(null);
            }
            if (!(typeof(CodeGroup).IsAssignableFrom(groupClass)))
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_NotACodeGroupType"));
            }

            group = (CodeGroup)Activator.CreateInstance(groupClass, true);

            Contract.Assert(groupClass.Module.Assembly != Assembly.GetExecutingAssembly(),
                            "This path should not get called for mscorlib based classes");

            return(group);
        }
Esempio n. 10
0
        static void Main(string[] args)
        {
            var assembly = Assembly.GetExecutingAssembly();

            int totalCount = 0;

            var dictionary = new Dictionary <string, string>();

            foreach (FileInfo fileInfo in new DirectoryInfo(new FileInfo(assembly.Location).DirectoryName).EnumerateFiles("*.log*").OrderBy(x => x.LastWriteTimeUtc))
            {
                Console.WriteLine("File: " + fileInfo.Name);
                using (StreamReader stream = fileInfo.OpenText()) {
                    while (!stream.EndOfStream)
                    {
                        var line = stream.ReadLine();
                        //Console.WriteLine("line: " + line);
                        //const string search = @"Begin Parallel processing BRs count: (\d+)";
                        //const string search = "Requesting BR processing for chunk count: ";
                        //const string search = @"Adding (\d+) messages to collector ActionBlock processing";
                        //const string search = @"BEGIN Try getting permissions of BR";
                        //const string search = @"BRs waiting in line: (\d+), vanilla ACL queue:";
                        const string beginSearch = @"BEGIN Try getting permissions of BR .*, \(ID: (\d+)\)";
                        const string endSearch   = @"END Try getting permissions of BR .*, \(ID: (\d+)\)";

                        var match = Regex.Match(line, beginSearch);
                        if (match.Success)
                        {
                            var resourceId = match.Groups[1].Value;
                            dictionary[resourceId] = match.Value;
                        }
                        match = Regex.Match(line, endSearch);
                        if (match.Success)
                        {
                            var resourceId = match.Groups[1].Value;
                            if (dictionary.ContainsKey(resourceId))
                            {
                                dictionary.Remove(resourceId);
                            }
                            else
                            {
                                Console.WriteLine("ERROR: found end without a previous begin for: " + resourceId +
                                                  ", " + match.Value);
                            }
                        }


                        //var match = Regex.Match(line, beginSearch);
                        //if (match.Success) {
                        //    if (match.Groups.Count > 1) {
                        //        string resultString = match.Groups[1].Value;
                        //        Console.WriteLine("resultString: " + match.Groups[1].Value);
                        //        var count = Int32.Parse(resultString);
                        //        Console.WriteLine("count: " + count);
                        //        totalCount += count;
                        //    }
                        //    else {
                        //        ++totalCount;
                        //    }
                        //}
                    }
                }
            }

            foreach (string key in dictionary.Keys)
            {
                Console.WriteLine("Unmatched: " + dictionary[key]);
            }

            Console.WriteLine("TOTAL: " + totalCount);
        }
    public void Execute()
    {
        webServiceType           = ModuleDefinition.ImportReference(typeof(WebService));
        taskBaseType             = ModuleDefinition.ImportReference(typeof(Task));
        taskOpenType             = ModuleDefinition.ImportReference(typeof(Task <>));
        iAsyncResultType         = ModuleDefinition.ImportReference(typeof(IAsyncResult));
        asyncCallbackType        = ModuleDefinition.ImportReference(typeof(AsyncCallback));
        taskCompletionSourceType = ModuleDefinition.ImportReference(typeof(TaskCompletionSource <>));
        objectCtor = ModuleDefinition.ImportReference(typeof(object).GetConstructor(new Type[0]));
        iEnumerableExceptionType  = ModuleDefinition.ImportReference(typeof(IEnumerable <Exception>));
        aggregateExceptionType    = ModuleDefinition.ImportReference(typeof(AggregateException));
        get_InnerExceptionsMethod = ModuleDefinition.ImportReference(typeof(AggregateException).GetMethod("get_InnerExceptions", new Type[0]));
        task_get_IsFaultedMethod  = new MethodReference("get_IsFaulted", ModuleDefinition.TypeSystem.Boolean, taskBaseType)
        {
            HasThis = true
        };
        task_get_ExceptionMethod = new MethodReference("get_Exception", aggregateExceptionType, taskBaseType)
        {
            HasThis = true
        };
        task_get_IsCanceledMethod = new MethodReference("get_IsCanceled", ModuleDefinition.TypeSystem.Boolean, taskBaseType)
        {
            HasThis = true
        };
        task_WaitMethod = new MethodReference("Wait", ModuleDefinition.TypeSystem.Void, taskBaseType)
        {
            HasThis = true
        };
        asyncCallbackInvokeMethod = new MethodReference("Invoke", ModuleDefinition.TypeSystem.Void, asyncCallbackType)
        {
            HasThis = true
        };
        asyncCallbackInvokeMethod.Parameters.Add(new ParameterDefinition(iAsyncResultType));
        actionOpenType                     = ModuleDefinition.ImportReference(typeof(Action <>));
        get_InnerExceptionMethod           = ModuleDefinition.ImportReference(typeof(Exception).GetMethod("get_InnerException", new Type[0]));
        exceptionDispatchInfoCaptureMethod = ModuleDefinition.ImportReference(
            ((Func <Exception, ExceptionDispatchInfo>)ExceptionDispatchInfo.Capture).Method);
        exceptionDispatchInfoThrowMethod = new MethodReference("Throw", ModuleDefinition.TypeSystem.Void,
                                                               exceptionDispatchInfoCaptureMethod.DeclaringType)
        {
            HasThis = true
        };

        generatedCodeAttributeCtor = ModuleDefinition.ImportReference(
            typeof(GeneratedCodeAttribute).GetConstructor(new Type[] { typeof(string), typeof(string) }));
        generatedCodeAttr = new CustomAttribute(generatedCodeAttributeCtor);
        generatedCodeAttr.ConstructorArguments.Add( // tool
            new CustomAttributeArgument(ModuleDefinition.TypeSystem.String, "AspNetLegacyWebServiceAsync.Fody"));
        generatedCodeAttr.ConstructorArguments.Add( // version
            new CustomAttributeArgument(ModuleDefinition.TypeSystem.String,
                                        Assembly.GetExecutingAssembly().GetName().Version.ToString()));

        var debuggerStepThroughCtor = ModuleDefinition.ImportReference(
            typeof(DebuggerStepThroughAttribute).GetConstructor(new Type[0]));

        debuggerStepThroughAttr = new CustomAttribute(debuggerStepThroughCtor);

        var orgTypes = ModuleDefinition.Types.ToList();

        foreach (var type in orgTypes)
        {
            if (IsDescendedFrom(webServiceType, type))
            {
                ModifyWebService(type);
            }
        }
    }
Esempio n. 12
0
        protected override void Load(ContainerBuilder builder)
        {
            var assembly = Assembly.GetExecutingAssembly();

            builder.RegisterType <CoreDbContext>()
            .As <IDbContext>()
            .InstancePerLifetimeScope();

            IEndpointInstance endpointInstance = null;

            builder.Register(c => endpointInstance)
            .As <IEndpointInstance>()
            .SingleInstance();

            #region Resources
            builder.RegisterType <ResourceService <SharedResource> >()
            .As <IResourceService <SharedResource> >()
            .InstancePerLifetimeScope();

            builder.RegisterType <ResourceService <GhmCoreResource> >()
            .As <IResourceService <GhmCoreResource> >()
            .InstancePerLifetimeScope();
            #endregion

            builder.RegisterType <TenantPageRepository>()
            .As <ITenantPageRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ProfileRepository>()
            .As <IProfileService>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientRepository>()
            .As <IClientRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientAllowedCorsOriginsRepository>()
            .As <IClientAllowedCorsOriginsRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientAllowedGrantTypeRepository>()
            .As <IClientAllowedGrantTypeRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientClaimRepository>()
            .As <IClientClaimRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientIdentityProviderRestrictionRepository>()
            .As <IClientIdentityProviderRestrictionRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientPostLogoutRedirectUrisRepository>()
            .As <IClientPostLogoutRedirectUrisRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientPropertyRepository>()
            .As <IClientPropertyRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientRedirectUrisRepository>()
            .As <IClientRedirectUrisRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientSecretRepository>()
            .As <IClientSecretRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ClientAllowedScopeRepository>()
            .As <IClientAllowedScopesRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <UserAccountRepository>()
            .As <IUserAccountRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <PageRepository>()
            .As <IPageRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <PageTranslationRepository>()
            .As <IPageTranslationRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ProvinceRepository>()
            .As <IProvinceRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <TenantRepository>()
            .As <ITenantRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <UserRoleRepository>()
            .As <IUserRoleRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <RolePageRepository>()
            .As <IRolePageRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <RoleRepository>()
            .As <IRoleRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <LanguageRepository>()
            .As <ILanguageRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <TenantLanguageRepository>()
            .As <ITenantLanguageRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <UserPermissionRepository>()
            .As <IUserPermissionRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <UserSettingRepository>()
            .As <IUserSettingRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <EthnicRepository>()
            .As <IEthnicRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ReligionRepository>()
            .As <IReligionRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <TagRepository>()
            .As <ITagRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <SubjectTagRepository>()
            .As <ISubjectTagRepository>()
            .InstancePerLifetimeScope();

            builder.RegisterType <ApproverConfigRepository>()
            .As <IApproverConfigRepository>()
            .InstancePerLifetimeScope();

            #region Resource Service.
            builder.RegisterType <ResourceService <SharedResource> >()
            .As <IResourceService <SharedResource> >()
            .InstancePerLifetimeScope();

            builder.RegisterType <ResourceService <GhmCoreResource> >()
            .As <IResourceService <GhmCoreResource> >()
            .InstancePerLifetimeScope();
            #endregion

            #region Services
            builder.RegisterAssemblyTypes(assembly)
            .Where(t => t.Name.EndsWith("Service"))
            .AsImplementedInterfaces();
            #endregion
        }
Esempio n. 13
0
        public FsmStateMachine(XmlDocument xmlDoc)
        {
            this.states = new Dictionary <string, State>();
            XmlNode root = xmlDoc.SelectSingleNode("StateMachine");

            fsmName = root.Attributes["name"].Value;
            XmlNodeList states = root.SelectNodes("State");

            for (int i = 0, size = states.Count; i < size; i++)
            {
                XmlNode stateNode = states[i];
                State   state     = new State(stateNode.Attributes["name"].Value);
                state.isDefault = stateNode.Attributes["isDefault"].Value == "true";
                XmlNodeList actions = stateNode.SelectSingleNode("Actions").SelectNodes("Action");
                for (int j = 0; j < actions.Count; j++)
                {
                    XmlNode   actionNode = actions[j];
                    string    className  = actionNode.Attributes["name"].Value;
                    FSMAction action     = (FSMAction)Reflection.GetExecutingAssembly().CreateInstance(className);
                    action.name = className;
                    XmlNodeList paramsNodes = actionNode.SelectSingleNode("params").SelectNodes("param");
                    for (int k = 0; k < paramsNodes.Count; k++)
                    {
                        XmlNode   paramNode    = paramsNodes[k];
                        string    propertyName = paramNode.Attributes["key"].Value;
                        Type      tp           = action.GetType();
                        FieldInfo pInfo        = tp.GetField(propertyName);
                        if (null == pInfo)
                        {
                            UnityEngine.Debug.LogError("获取条件名为: " + action.name + "的属性 " + paramNode.Attributes["key"].Value + "不存在");
                            return;
                        }
                        pInfo.SetValue(action, paramNode.Attributes["value"].Value);
                    }
                    state.AddAction(action);
                }

                XmlNodeList transitions = stateNode.SelectSingleNode("Transitions").SelectNodes("Transition");
                for (int j = 0; j < transitions.Count; j++)
                {
                    XmlNode     transitionNode  = transitions[j];
                    Transition  trans           = new Transition(transitionNode.Attributes["name"].Value, state.name, transitionNode.Attributes["toState"].Value);
                    XmlNodeList conditionsNodes = transitionNode.SelectSingleNode("Conditions").SelectNodes("Condition");
                    for (int k = 0; k < conditionsNodes.Count; k++)
                    {
                        XmlNode      conditionNode = conditionsNodes[k];
                        string       className     = conditionNode.Attributes["name"].Value;
                        FSMCondition condition     = (FSMCondition)Reflection.GetExecutingAssembly().CreateInstance(className);
                        condition.name = className;
                        XmlNodeList paramsNodes = conditionNode.SelectSingleNode("params").SelectNodes("param");
                        for (int m = 0; m < paramsNodes.Count; m++)
                        {
                            XmlNode   paramNode = paramsNodes[m];
                            FieldInfo pInfo     = condition.GetType().GetField(paramNode.Attributes["key"].Value);
                            if (null == pInfo)
                            {
                                UnityEngine.Debug.LogError("获取条件名为: " + condition.name + "的属性 " + paramNode.Attributes["key"].Value + "不存在");
                                return;
                            }
                            // UnityEngine.Debug.Log("获取条件名为: " + condition.name + "的属性 " + paramNode.Attributes["key"].Value + "不存在");
                            pInfo.SetValue(condition, paramNode.Attributes["value"].Value);
                        }
                        trans.AddCondition(condition);
                    }
                    state.AddTransition(trans);
                }

                AddState(state);
            }
        }
Esempio n. 14
0
        public void RunTest(Generator test, bool exe, string testName = null)
        {
            if (test == null)
            {
                throw new ArgumentNullException(nameof(test));
            }
            testName = testName ?? GetTestName(test);
            Console.WriteLine(">>> GEN {0}", testName);
            string name = testName;

            string exeDir      = string.Empty;
            string exeFilePath = string.Empty;

            if (exe)
            {
                exeDir      = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
                exeFilePath = Path.Combine(exeDir, name + ".exe");
                Directory.CreateDirectory(exeDir);
            }

            AssemblyGen asm;

            asm = !exe
                      ? new AssemblyGen(name, new CompilerOptions())
                      : new AssemblyGen(name, new CompilerOptions()
            {
                OutputPath = exeFilePath
            });
            test(asm);
            if (exe)
            {
                asm.Save();
                PEVerify.AssertValid(exeFilePath);
            }
            Console.WriteLine("=== RUN {0}", testName);

            string[] testArguments = GetTestArguments(test);

            bool useReflectionEntryPoint = !exe;

#if NET5_0
            useReflectionEntryPoint = true;
#endif
#if !FEAT_IKVM
            if (useReflectionEntryPoint)
            {
#if SILVERLIGHT || NET5_0
                Type entryType = asm.GetAssembly().DefinedTypes.First(t => t.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) != null);
#else
                Type entryType = ((TypeBuilder)asm.GetAssembly().EntryPoint.DeclaringType).CreateType();
#endif

                MethodInfo entryMethod = entryType.GetMethod(asm.GetAssembly().EntryPoint?.Name ?? "Main", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                object[]   entryArgs   = null;
                if (entryMethod.GetParameters().Length == 1)
                {
                    entryArgs = new object[] { testArguments };
                }
                entryMethod.Invoke(null, entryArgs);
            }
            else
#endif
            {
                try
                {
                    AppDomain.CurrentDomain.ExecuteAssembly(exeFilePath, testArguments);
                }
                catch (System.BadImageFormatException)
                {
                    throw;
                }
                catch (AppDomainUnloadedException)
                {
                    throw;
                }
                catch (Exception e)
                {
#if SILVERLIGHT
                    throw;
#else
                    throw new TargetInvocationException(e);
#endif
                }
            }

            Console.WriteLine("<<< END {0}", testName);
            Console.WriteLine();

            if (exe)
            {
                try
                {
                    File.Delete(exeFilePath);
                }
                catch { }
            }
        }
Esempio n. 15
0
 /// <summary>
 /// バージョン文字列を取得
 /// </summary>
 /// <returns>バージョン文字列</returns>
 public static string GetVersionString()
 {
     return(SRA.GetExecutingAssembly().GetName().Version.ToString());
 }