fix IEnum->IReadonlyList

tk-yoshimura · tk-yoshimura · commit 758585b8b23a · 2021-11-23T02:23:32.000+09:00
diff --git a/TensorShader/Field.cs b/TensorShader/Field.cs
@@ -239,7 +239,7 @@ public void AddUpdater(Updater updater) {
         }
 
         /// <summary>更新則を追加</summary>
-        public void AddUpdaters(IEnumerable<Updater> updaters) {
+        public void AddUpdaters(IReadOnlyList<Updater> updaters) {
             foreach (Updater updater in updaters) {
                 AddUpdater(updater);
             }
diff --git a/TensorShader/Flow.cs b/TensorShader/Flow.cs
@@ -109,7 +109,7 @@ public static Flow FromOutputs(params OutputNode[] outnodes) {
         /// <param name="innodes">入力ノードリスト</param>
         /// <param name="tracenodes">フロー関連ノード</param>
         /// <remarks>フロー関連ノードがnullであるなら入力ノードから到達できるノードをフロー関連ノードとする</remarks>
-        internal static List<Node> ExecutionOrderSort(IEnumerable<InputNode> innodes, List<Node> tracenodes = null) {
+        internal static List<Node> ExecutionOrderSort(IReadOnlyList<InputNode> innodes, List<Node> tracenodes = null) {
             List<Tensor> input_tensors =
                 innodes
                 .Where((node) => node.Tensor is not null)
diff --git a/TensorShader/NdimArray/NdimArray.cs b/TensorShader/NdimArray/NdimArray.cs
@@ -195,11 +195,15 @@ public virtual NdimArray<T> this[int index] {
         }
 
         /// <summary>データリスト</summary>
-        public IEnumerable<(int index, NdimArray<T> data)> DataList {
+        public (int index, NdimArray<T> data)[] DataList {
             get {
+                (int index, NdimArray<T> data)[] datas = new (int index, NdimArray<T> data)[Batch];
+
                 for (int i = 0; i < Batch; i++) {
-                    yield return (i, this[i]);
+                    datas[i] = (i, this[i]);
                 }
+
+                return datas;
             }
         }
 
diff --git a/TensorShader/Parameters.cs b/TensorShader/Parameters.cs
@@ -6,14 +6,14 @@
 namespace TensorShader {
     /// <summary>パラメータコンテナ</summary>
     public class Parameters {
-        private readonly List<ParameterField> parameter_fields;
+        private readonly IReadOnlyList<ParameterField> parameter_fields;
 
         /// <summary>パラメータ数</summary>
         public int Count => parameter_fields.Count;
 
         /// <summary>コンストラクタ</summary>
-        public Parameters(IEnumerable<ParameterField> parameter_fields) {
-            this.parameter_fields = new List<ParameterField>(parameter_fields);
+        public Parameters(IReadOnlyList<ParameterField> parameter_fields) {
+            this.parameter_fields = parameter_fields;
         }
 
         /// <summary>リストからキャスト</summary>
@@ -28,22 +28,22 @@ public static implicit operator List<ParameterField>(Parameters parameters) {
 
         /// <summary>和集合</summary>
         public static Parameters operator +(Parameters p1, Parameters p2) {
-            return new Parameters(p1.parameter_fields.Union(p2.parameter_fields));
+            return new Parameters(p1.parameter_fields.Union(p2.parameter_fields).ToList());
         }
 
         /// <summary>積集合</summary>
         public static Parameters operator *(Parameters p1, Parameters p2) {
-            return new Parameters(p1.parameter_fields.Intersect(p2.parameter_fields));
+            return new Parameters(p1.parameter_fields.Intersect(p2.parameter_fields).ToList());
         }
 
         /// <summary>差集合</summary>
         public static Parameters operator -(Parameters p1, Parameters p2) {
-            return new Parameters(p1.parameter_fields.Except(p2.parameter_fields));
+            return new Parameters(p1.parameter_fields.Except(p2.parameter_fields).ToList());
         }
 
         /// <summary>条件抜き出し</summary>
         public Parameters Where(Func<ParameterField, bool> predicate) {
-            return new Parameters(parameter_fields.Where(predicate));
+            return new Parameters(parameter_fields.Where(predicate).ToList());
         }
 
         /// <summary>更新則を追加</summary>
@@ -62,7 +62,7 @@ public Parameters AddUpdater(Func<ParameterField, Updater> gen_updater) {
 
         /// <summary>更新則を追加</summary>
         /// <returns>メゾットチェーン可</returns>
-        public Parameters AddUpdaters(Func<ParameterField, IEnumerable<Updater>> gen_updater) {
+        public Parameters AddUpdaters(Func<ParameterField, IReadOnlyList<Updater>> gen_updater) {
             if (parameter_fields.Count <= 0) {
                 throw new InvalidOperationException(ExceptionMessage.EmptyList());
             }
diff --git a/TensorShader/Properties/AssemblyInfo.cs b/TensorShader/Properties/AssemblyInfo.cs
@@ -21,6 +21,6 @@
 
 [assembly: Guid("e6d7e72c-eb7a-4697-9b1a-3e87ba76323a")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
 
 [assembly: InternalsVisibleTo("TensorShaderTest")]
diff --git a/TensorShaderCudaBackend/Dll/CudaDll.cs b/TensorShaderCudaBackend/Dll/CudaDll.cs
@@ -74,113 +74,133 @@ static CudaDll() {
             }
         }
 
-        static IEnumerable<(int major, int minor)> VersionList {
+        static IReadOnlyList<(int major, int minor)> VersionList {
             get {
+                List<(int major, int minor)> versions = new();
+
                 for (int major = 11; major >= 10; major--) {
                     for (int minor = 9; minor >= 0; minor--) {
-                        yield return (major, minor);
+                        versions.Add((major, minor));
                     }
                 }
+
+                return versions;
             }
         }
 
-        static IEnumerable<string> NvcudaLibraryNames {
+        static IReadOnlyList<string> NvcudaLibraryNames {
             get {
+                List<string> libnames = new();
+
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
-                    yield return "nvcuda.dll";
+                    libnames.Add("nvcuda.dll");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {
-                    yield return "libcuda.so";
+                    libnames.Add("libcuda.so");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {
-                    yield return "libcuda.dylib";
+                    libnames.Add("libcuda.dylib");
                 }
                 else {
                     throw new NotSupportedException(RuntimeInformation.OSDescription);
                 }
+
+                return libnames;
             }
         }
 
-        static IEnumerable<string> CudaLibraryNames {
+        static IReadOnlyList<string> CudaLibraryNames {
             get {
+                List<string> libnames = new();
+
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"cudart64_{major}{minor}.dll";
+                        libnames.Add($"cudart64_{major}{minor}.dll");
                     }
 
-                    yield return "cudart64.dll";
+                    libnames.Add("cudart64.dll");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"libcudart.so.{major}.{minor}";
+                        libnames.Add($"libcudart.so.{major}.{minor}");
                     }
 
-                    yield return "libcudart.so";
+                    libnames.Add("libcudart.so");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"libcudart.{major}.{minor}.dylib";
+                        libnames.Add($"libcudart.{major}.{minor}.dylib");
                     }
 
-                    yield return "libcudart.dylib";
+                    libnames.Add("libcudart.dylib");
                 }
                 else {
                     throw new NotSupportedException(RuntimeInformation.OSDescription);
                 }
+
+                return libnames;
             }
         }
 
-        static IEnumerable<string> NvrtcLibraryNames {
+        static IReadOnlyList<string> NvrtcLibraryNames {
             get {
+                List<string> libnames = new();
+
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"nvrtc64_{major}{minor}_0.dll";
+                        libnames.Add($"nvrtc64_{major}{minor}_0.dll");
                     }
 
-                    yield return "nvrtc64.dll";
+                    libnames.Add("nvrtc64.dll");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"libnvrtc.so.{major}.{minor}";
+                        libnames.Add($"libnvrtc.so.{major}.{minor}");
                     }
 
-                    yield return "libnvrtc.so";
+                    libnames.Add("libnvrtc.so");
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {
                     foreach ((int major, int minor) in VersionList) {
-                        yield return $"libnvrtc.{major}.{minor}.dylib";
+                        libnames.Add($"libnvrtc.{major}.{minor}.dylib");
                     }
 
-                    yield return "libnvrtc.dylib";
+                    libnames.Add("libnvrtc.dylib");
                 }
                 else {
                     throw new NotSupportedException(RuntimeInformation.OSDescription);
                 }
+
+                return libnames;
             }
         }
 
-        static IEnumerable<(int version, string libname)> CudnnLibraryNames {
+        static IReadOnlyList<(int version, string libname)> CudnnLibraryNames {
             get {
+                List<(int version, string libname)> libnames = new();
+
                 int[] cudnn_versions = new int[] { 8, 7 };
 
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {
                     foreach (int version in cudnn_versions) {
-                        yield return (version, $"cudnn64_{version}.dll");
+                        libnames.Add((version, $"cudnn64_{version}.dll"));
                     }
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {
                     foreach (int version in cudnn_versions) {
-                        yield return (version, $"libcudnn.so.{version}");
+                        libnames.Add((version, $"libcudnn.so.{version}"));
                     }
                 }
                 else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {
                     foreach (int version in cudnn_versions) {
-                        yield return (version, $"libcudnn.{version}.dylib");
+                        libnames.Add((version, $"libcudnn.{version}.dylib"));
                     }
                 }
                 else {
                     throw new NotSupportedException(RuntimeInformation.OSDescription);
                 }
+
+                return libnames;
             }
         }
 
diff --git a/TensorShaderCudaBackend/Properties/AssemblyInfo.cs b/TensorShaderCudaBackend/Properties/AssemblyInfo.cs
@@ -21,6 +21,6 @@
 
 [assembly: Guid("d0343c7a-36a5-4f87-89d9-c0bff56721f7")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
 
 [assembly: InternalsVisibleTo("TensorShaderCudaBackendTest")]
diff --git a/TensorShaderCudaBackendTest/Properties/AssemblyInfo.cs b/TensorShaderCudaBackendTest/Properties/AssemblyInfo.cs
@@ -20,4 +20,4 @@
 
 [assembly: Guid("6f14bf0a-748a-4f30-89b8-e42adc2e7480")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
diff --git a/TensorShaderPreset/Properties/AssemblyInfo.cs b/TensorShaderPreset/Properties/AssemblyInfo.cs
@@ -20,4 +20,4 @@
 
 [assembly: Guid("5c4cedaf-3962-4d5b-b17f-35fa788f2016")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
diff --git a/TensorShaderTest/Properties/AssemblyInfo.cs b/TensorShaderTest/Properties/AssemblyInfo.cs
@@ -20,4 +20,4 @@
 
 [assembly: Guid("66a05297-9440-42a4-855f-2fd162428b8b")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
diff --git a/TensorShaderUtil/Properties/AssemblyInfo.cs b/TensorShaderUtil/Properties/AssemblyInfo.cs
@@ -20,4 +20,4 @@
 
 [assembly: Guid("9291e2d8-e250-4886-8845-aaf42b3c070c")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]
diff --git a/TensorShaderUtil/SerialFileUtil/SerialFileUtil.cs b/TensorShaderUtil/SerialFileUtil/SerialFileUtil.cs
@@ -13,7 +13,7 @@ public static class SerialFileUtil {
         /// <param name="directory_path">ディレクトリパス</param>
         /// <param name="filename_pattern">ファイル名パターン e.g. ( test*.txt )</param>
         /// <returns>ファイルパス及び連番</returns>
-        public static IEnumerable<(string path, long num)> EnumrateSerialFiles(string directory_path, string filename_pattern) {
+        public static IReadOnlyList<(string path, long num)> EnumrateSerialFiles(string directory_path, string filename_pattern) {
             if (!filename_pattern.Contains('*') || filename_pattern.IndexOf('*', filename_pattern.IndexOf('*') + 1) >= 0) {
                 throw new ArgumentException(null, nameof(filename_pattern));
             }
@@ -31,7 +31,7 @@ public static class SerialFileUtil {
                 return (filepath, num: long.MinValue);
             }).Where((item) => item.num != long.MinValue);
 
-            return filepaths_serials;
+            return filepaths_serials.ToList();
         }
 
         /// <summary>最大の連番ファイルを返す</summary>
diff --git a/TensorShaderUtilTest/Properties/AssemblyInfo.cs b/TensorShaderUtilTest/Properties/AssemblyInfo.cs
@@ -20,4 +20,4 @@
 
 [assembly: Guid("cfdcbb3a-d8a8-47d6-a099-e834e881502c")]
 
-[assembly: AssemblyVersion("5.5.1.*")]
+[assembly: AssemblyVersion("5.5.3.*")]

Original file line number	Diff line number	Diff line change
`@@ -239,7 +239,7 @@ public void AddUpdater(Updater updater) {`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`/// <summary>更新則を追加</summary>`
`242`		`- public void AddUpdaters(IEnumerable<Updater> updaters) {`
	`242`	`+ public void AddUpdaters(IReadOnlyList<Updater> updaters) {`
`243`	`243`	`foreach (Updater updater in updaters) {`
`244`	`244`	`AddUpdater(updater);`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -195,11 +195,15 @@ public virtual NdimArray<T> this[int index] {`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`/// <summary>データリスト</summary>`
`198`		`- public IEnumerable<(int index, NdimArray<T> data)> DataList {`
	`198`	`+ public (int index, NdimArray<T> data)[] DataList {`
`199`	`199`	`get {`
	`200`	`+ (int index, NdimArray<T> data)[] datas = new (int index, NdimArray<T> data)[Batch];`
	`201`	`+`
`200`	`202`	`for (int i = 0; i < Batch; i++) {`
`201`		`- yield return (i, this[i]);`
	`203`	`+ datas[i] = (i, this[i]);`
`202`	`204`	`}`
	`205`	`+`
	`206`	`+ return datas;`
`203`	`207`	`}`
`204`	`208`	`}`
`205`	`209`
Original file line number	Diff line number	Diff line change
`@@ -74,113 +74,133 @@ static CudaDll() {`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`		`- static IEnumerable<(int major, int minor)> VersionList {`
	`77`	`+ static IReadOnlyList<(int major, int minor)> VersionList {`
`78`	`78`	`get {`
	`79`	`+ List<(int major, int minor)> versions = new();`
	`80`	`+`
`79`	`81`	`for (int major = 11; major >= 10; major--) {`
`80`	`82`	`for (int minor = 9; minor >= 0; minor--) {`
`81`		`- yield return (major, minor);`
	`83`	`+ versions.Add((major, minor));`
`82`	`84`	`}`
`83`	`85`	`}`
	`86`	`+`
	`87`	`+ return versions;`
`84`	`88`	`}`
`85`	`89`	`}`
`86`	`90`
`87`		`- static IEnumerable<string> NvcudaLibraryNames {`
	`91`	`+ static IReadOnlyList<string> NvcudaLibraryNames {`
`88`	`92`	`get {`
	`93`	`+ List<string> libnames = new();`
	`94`	`+`
`89`	`95`	`if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {`
`90`		`- yield return "nvcuda.dll";`
	`96`	`+ libnames.Add("nvcuda.dll");`
`91`	`97`	`}`
`92`	`98`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {`
`93`		`- yield return "libcuda.so";`
	`99`	`+ libnames.Add("libcuda.so");`
`94`	`100`	`}`
`95`	`101`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {`
`96`		`- yield return "libcuda.dylib";`
	`102`	`+ libnames.Add("libcuda.dylib");`
`97`	`103`	`}`
`98`	`104`	`else {`
`99`	`105`	`throw new NotSupportedException(RuntimeInformation.OSDescription);`
`100`	`106`	`}`
	`107`	`+`
	`108`	`+ return libnames;`
`101`	`109`	`}`
`102`	`110`	`}`
`103`	`111`
`104`		`- static IEnumerable<string> CudaLibraryNames {`
	`112`	`+ static IReadOnlyList<string> CudaLibraryNames {`
`105`	`113`	`get {`
	`114`	`+ List<string> libnames = new();`
	`115`	`+`
`106`	`116`	`if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {`
`107`	`117`	`foreach ((int major, int minor) in VersionList) {`
`108`		`- yield return $"cudart64_{major}{minor}.dll";`
	`118`	`+ libnames.Add($"cudart64_{major}{minor}.dll");`
`109`	`119`	`}`
`110`	`120`
`111`		`- yield return "cudart64.dll";`
	`121`	`+ libnames.Add("cudart64.dll");`
`112`	`122`	`}`
`113`	`123`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {`
`114`	`124`	`foreach ((int major, int minor) in VersionList) {`
`115`		`- yield return $"libcudart.so.{major}.{minor}";`
	`125`	`+ libnames.Add($"libcudart.so.{major}.{minor}");`
`116`	`126`	`}`
`117`	`127`
`118`		`- yield return "libcudart.so";`
	`128`	`+ libnames.Add("libcudart.so");`
`119`	`129`	`}`
`120`	`130`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {`
`121`	`131`	`foreach ((int major, int minor) in VersionList) {`
`122`		`- yield return $"libcudart.{major}.{minor}.dylib";`
	`132`	`+ libnames.Add($"libcudart.{major}.{minor}.dylib");`
`123`	`133`	`}`
`124`	`134`
`125`		`- yield return "libcudart.dylib";`
	`135`	`+ libnames.Add("libcudart.dylib");`
`126`	`136`	`}`
`127`	`137`	`else {`
`128`	`138`	`throw new NotSupportedException(RuntimeInformation.OSDescription);`
`129`	`139`	`}`
	`140`	`+`
	`141`	`+ return libnames;`
`130`	`142`	`}`
`131`	`143`	`}`
`132`	`144`
`133`		`- static IEnumerable<string> NvrtcLibraryNames {`
	`145`	`+ static IReadOnlyList<string> NvrtcLibraryNames {`
`134`	`146`	`get {`
	`147`	`+ List<string> libnames = new();`
	`148`	`+`
`135`	`149`	`if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {`
`136`	`150`	`foreach ((int major, int minor) in VersionList) {`
`137`		`- yield return $"nvrtc64_{major}{minor}_0.dll";`
	`151`	`+ libnames.Add($"nvrtc64_{major}{minor}_0.dll");`
`138`	`152`	`}`
`139`	`153`
`140`		`- yield return "nvrtc64.dll";`
	`154`	`+ libnames.Add("nvrtc64.dll");`
`141`	`155`	`}`
`142`	`156`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {`
`143`	`157`	`foreach ((int major, int minor) in VersionList) {`
`144`		`- yield return $"libnvrtc.so.{major}.{minor}";`
	`158`	`+ libnames.Add($"libnvrtc.so.{major}.{minor}");`
`145`	`159`	`}`
`146`	`160`
`147`		`- yield return "libnvrtc.so";`
	`161`	`+ libnames.Add("libnvrtc.so");`
`148`	`162`	`}`
`149`	`163`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {`
`150`	`164`	`foreach ((int major, int minor) in VersionList) {`
`151`		`- yield return $"libnvrtc.{major}.{minor}.dylib";`
	`165`	`+ libnames.Add($"libnvrtc.{major}.{minor}.dylib");`
`152`	`166`	`}`
`153`	`167`
`154`		`- yield return "libnvrtc.dylib";`
	`168`	`+ libnames.Add("libnvrtc.dylib");`
`155`	`169`	`}`
`156`	`170`	`else {`
`157`	`171`	`throw new NotSupportedException(RuntimeInformation.OSDescription);`
`158`	`172`	`}`
	`173`	`+`
	`174`	`+ return libnames;`
`159`	`175`	`}`
`160`	`176`	`}`
`161`	`177`
`162`		`- static IEnumerable<(int version, string libname)> CudnnLibraryNames {`
	`178`	`+ static IReadOnlyList<(int version, string libname)> CudnnLibraryNames {`
`163`	`179`	`get {`
	`180`	`+ List<(int version, string libname)> libnames = new();`
	`181`	`+`
`164`	`182`	`int[] cudnn_versions = new int[] { 8, 7 };`
`165`	`183`
`166`	`184`	`if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) {`
`167`	`185`	`foreach (int version in cudnn_versions) {`
`168`		`- yield return (version, $"cudnn64_{version}.dll");`
	`186`	`+ libnames.Add((version, $"cudnn64_{version}.dll"));`
`169`	`187`	`}`
`170`	`188`	`}`
`171`	`189`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {`
`172`	`190`	`foreach (int version in cudnn_versions) {`
`173`		`- yield return (version, $"libcudnn.so.{version}");`
	`191`	`+ libnames.Add((version, $"libcudnn.so.{version}"));`
`174`	`192`	`}`
`175`	`193`	`}`
`176`	`194`	`else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {`
`177`	`195`	`foreach (int version in cudnn_versions) {`
`178`		`- yield return (version, $"libcudnn.{version}.dylib");`
	`196`	`+ libnames.Add((version, $"libcudnn.{version}.dylib"));`
`179`	`197`	`}`
`180`	`198`	`}`
`181`	`199`	`else {`
`182`	`200`	`throw new NotSupportedException(RuntimeInformation.OSDescription);`
`183`	`201`	`}`
	`202`	`+`
	`203`	`+ return libnames;`
`184`	`204`	`}`
`185`	`205`	`}`
`186`	`206`
Original file line number	Diff line number	Diff line change
`@@ -20,4 +20,4 @@`
`20`	`20`
`21`	`21`	`[assembly: Guid("6f14bf0a-748a-4f30-89b8-e42adc2e7480")]`
`22`	`22`
`23`		`-[assembly: AssemblyVersion("5.5.1.*")]`
	`23`	`+[assembly: AssemblyVersion("5.5.3.*")]`