diff --git a/AutoRetainerAPI b/AutoRetainerAPI index 2715088..6f0aaa5 160000 --- a/AutoRetainerAPI +++ b/AutoRetainerAPI @@ -1 +1 @@ -Subproject commit 2715088db81d2be34447b27b0e5e5a3e766e47c7 +Subproject commit 6f0aaa55bce6ec79fd4d72f84f21597b39e5445d diff --git a/ECommons b/ECommons index f1c688a..d238d41 160000 --- a/ECommons +++ b/ECommons @@ -1 +1 @@ -Subproject commit f1c688a0599b41d70230021328a575da7351cf91 +Subproject commit d238d4188e8b47b11252d75cb5e4b678b8da2756 diff --git a/Influx.sln.DotSettings b/Influx.sln.DotSettings new file mode 100644 index 0000000..6a6eae6 --- /dev/null +++ b/Influx.sln.DotSettings @@ -0,0 +1,2 @@ + + True \ No newline at end of file diff --git a/Influx/.editorconfig b/Influx/.editorconfig new file mode 100644 index 0000000..6a4af82 --- /dev/null +++ b/Influx/.editorconfig @@ -0,0 +1,1017 @@ +# NOTE: Requires **VS2019 16.3** or later + +# All Rules Enabled as build warnings +# Description: All Rules are enabled as build warnings. Rules with IsEnabledByDefault = false are force enabled as build warnings. + +# Code files +[*.{cs,vb}] + + +# CA1000: Do not declare static members on generic types +dotnet_diagnostic.CA1000.severity = warning + +# CA1001: Types that own disposable fields should be disposable +dotnet_diagnostic.CA1001.severity = warning + +# CA1002: Do not expose generic lists +dotnet_diagnostic.CA1002.severity = warning + +# CA1003: Use generic event handler instances +dotnet_diagnostic.CA1003.severity = warning + +# CA1005: Avoid excessive parameters on generic types +dotnet_diagnostic.CA1005.severity = warning + +# CA1008: Enums should have zero value +dotnet_diagnostic.CA1008.severity = warning + +# CA1010: Generic interface should also be implemented +dotnet_diagnostic.CA1010.severity = warning + +# CA1012: Abstract types should not have public constructors +dotnet_diagnostic.CA1012.severity = warning + +# CA1014: Mark assemblies with CLSCompliant +dotnet_diagnostic.CA1014.severity = warning + +# CA1016: Mark assemblies with assembly version +dotnet_diagnostic.CA1016.severity = warning + +# CA1017: Mark assemblies with ComVisible +dotnet_diagnostic.CA1017.severity = warning + +# CA1018: Mark attributes with AttributeUsageAttribute +dotnet_diagnostic.CA1018.severity = warning + +# CA1019: Define accessors for attribute arguments +dotnet_diagnostic.CA1019.severity = warning + +# CA1021: Avoid out parameters +dotnet_diagnostic.CA1021.severity = none + +# CA1024: Use properties where appropriate +dotnet_diagnostic.CA1024.severity = warning + +# CA1027: Mark enums with FlagsAttribute +dotnet_diagnostic.CA1027.severity = warning + +# CA1028: Enum Storage should be Int32 +dotnet_diagnostic.CA1028.severity = warning + +# CA1030: Use events where appropriate +dotnet_diagnostic.CA1030.severity = warning + +# CA1031: Do not catch general exception types +dotnet_diagnostic.CA1031.severity = suggestion + +# CA1032: Implement standard exception constructors +dotnet_diagnostic.CA1032.severity = warning + +# CA1033: Interface methods should be callable by child types +dotnet_diagnostic.CA1033.severity = warning + +# CA1034: Nested types should not be visible +dotnet_diagnostic.CA1034.severity = warning + +# CA1036: Override methods on comparable types +dotnet_diagnostic.CA1036.severity = warning + +# CA1040: Avoid empty interfaces +dotnet_diagnostic.CA1040.severity = warning + +# CA1041: Provide ObsoleteAttribute message +dotnet_diagnostic.CA1041.severity = warning + +# CA1043: Use Integral Or String Argument For Indexers +dotnet_diagnostic.CA1043.severity = warning + +# CA1044: Properties should not be write only +dotnet_diagnostic.CA1044.severity = warning + +# CA1045: Do not pass types by reference +dotnet_diagnostic.CA1045.severity = warning + +# CA1046: Do not overload equality operator on reference types +dotnet_diagnostic.CA1046.severity = warning + +# CA1047: Do not declare protected member in sealed type +dotnet_diagnostic.CA1047.severity = warning + +# CA1050: Declare types in namespaces +dotnet_diagnostic.CA1050.severity = warning + +# CA1051: Do not declare visible instance fields +dotnet_diagnostic.CA1051.severity = warning + +# CA1052: Static holder types should be Static or NotInheritable +dotnet_diagnostic.CA1052.severity = warning + +# CA1054: URI-like parameters should not be strings +dotnet_diagnostic.CA1054.severity = warning + +# CA1055: URI-like return values should not be strings +dotnet_diagnostic.CA1055.severity = warning + +# CA1056: URI-like properties should not be strings +dotnet_diagnostic.CA1056.severity = warning + +# CA1058: Types should not extend certain base types +dotnet_diagnostic.CA1058.severity = warning + +# CA1060: Move pinvokes to native methods class +dotnet_diagnostic.CA1060.severity = warning + +# CA1061: Do not hide base class methods +dotnet_diagnostic.CA1061.severity = warning + +# CA1062: Validate arguments of public methods +dotnet_diagnostic.CA1062.severity = warning + +# CA1063: Implement IDisposable Correctly +dotnet_diagnostic.CA1063.severity = warning + +# CA1064: Exceptions should be public +dotnet_diagnostic.CA1064.severity = warning + +# CA1065: Do not raise exceptions in unexpected locations +dotnet_diagnostic.CA1065.severity = warning + +# CA1066: Implement IEquatable when overriding Object.Equals +dotnet_diagnostic.CA1066.severity = warning + +# CA1067: Override Object.Equals(object) when implementing IEquatable +dotnet_diagnostic.CA1067.severity = warning + +# CA1068: CancellationToken parameters must come last +dotnet_diagnostic.CA1068.severity = warning + +# CA1069: Enums values should not be duplicated +dotnet_diagnostic.CA1069.severity = warning + +# CA1070: Do not declare event fields as virtual +dotnet_diagnostic.CA1070.severity = warning + +# CA1200: Avoid using cref tags with a prefix +dotnet_diagnostic.CA1200.severity = warning + +# CA1303: Do not pass literals as localized parameters +dotnet_diagnostic.CA1303.severity = warning + +# CA1304: Specify CultureInfo +dotnet_diagnostic.CA1304.severity = warning + +# CA1305: Specify IFormatProvider +dotnet_diagnostic.CA1305.severity = warning + +# CA1307: Specify StringComparison for clarity +dotnet_diagnostic.CA1307.severity = warning + +# CA1308: Normalize strings to uppercase +dotnet_diagnostic.CA1308.severity = warning + +# CA1309: Use ordinal string comparison +dotnet_diagnostic.CA1309.severity = warning + +# CA1310: Specify StringComparison for correctness +dotnet_diagnostic.CA1310.severity = warning + +# CA1311: Specify a culture or use an invariant version +dotnet_diagnostic.CA1311.severity = warning + +# CA1401: P/Invokes should not be visible +dotnet_diagnostic.CA1401.severity = warning + +# CA1416: Validate platform compatibility +dotnet_diagnostic.CA1416.severity = warning + +# CA1417: Do not use 'OutAttribute' on string parameters for P/Invokes +dotnet_diagnostic.CA1417.severity = warning + +# CA1418: Use valid platform string +dotnet_diagnostic.CA1418.severity = warning + +# CA1419: Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle' +dotnet_diagnostic.CA1419.severity = warning + +# CA1420: Property, type, or attribute requires runtime marshalling +dotnet_diagnostic.CA1420.severity = warning + +# CA1421: This method uses runtime marshalling even when the 'DisableRuntimeMarshallingAttribute' is applied +dotnet_diagnostic.CA1421.severity = warning + +# CA1422: Validate platform compatibility +dotnet_diagnostic.CA1422.severity = warning + +# CA1501: Avoid excessive inheritance +dotnet_diagnostic.CA1501.severity = warning + +# CA1502: Avoid excessive complexity +dotnet_diagnostic.CA1502.severity = suggestion + +# CA1505: Avoid unmaintainable code +dotnet_diagnostic.CA1505.severity = warning + +# CA1506: Avoid excessive class coupling +dotnet_diagnostic.CA1506.severity = warning + +# CA1507: Use nameof to express symbol names +dotnet_diagnostic.CA1507.severity = warning + +# CA1508: Avoid dead conditional code +dotnet_diagnostic.CA1508.severity = warning + +# CA1509: Invalid entry in code metrics rule specification file +dotnet_diagnostic.CA1509.severity = warning + +# CA1510: Use ArgumentNullException throw helper +dotnet_diagnostic.CA1510.severity = warning + +# CA1511: Use ArgumentException throw helper +dotnet_diagnostic.CA1511.severity = warning + +# CA1512: Use ArgumentOutOfRangeException throw helper +dotnet_diagnostic.CA1512.severity = warning + +# CA1513: Use ObjectDisposedException throw helper +dotnet_diagnostic.CA1513.severity = warning + +# CA1700: Do not name enum values 'Reserved' +dotnet_diagnostic.CA1700.severity = warning + +# CA1707: Identifiers should not contain underscores +dotnet_diagnostic.CA1707.severity = warning + +# CA1708: Identifiers should differ by more than case +dotnet_diagnostic.CA1708.severity = warning + +# CA1710: Identifiers should have correct suffix +dotnet_diagnostic.CA1710.severity = warning + +# CA1711: Identifiers should not have incorrect suffix +dotnet_diagnostic.CA1711.severity = warning + +# CA1712: Do not prefix enum values with type name +dotnet_diagnostic.CA1712.severity = warning + +# CA1713: Events should not have 'Before' or 'After' prefix +dotnet_diagnostic.CA1713.severity = warning + +# CA1715: Identifiers should have correct prefix +dotnet_diagnostic.CA1715.severity = warning + +# CA1716: Identifiers should not match keywords +dotnet_diagnostic.CA1716.severity = warning + +# CA1720: Identifier contains type name +dotnet_diagnostic.CA1720.severity = warning + +# CA1721: Property names should not match get methods +dotnet_diagnostic.CA1721.severity = warning + +# CA1724: Type names should not match namespaces +dotnet_diagnostic.CA1724.severity = warning + +# CA1725: Parameter names should match base declaration +dotnet_diagnostic.CA1725.severity = warning + +# CA1727: Use PascalCase for named placeholders +dotnet_diagnostic.CA1727.severity = warning + +# CA1802: Use literals where appropriate +dotnet_diagnostic.CA1802.severity = warning + +# CA1805: Do not initialize unnecessarily +dotnet_diagnostic.CA1805.severity = warning + +# CA1806: Do not ignore method results +dotnet_diagnostic.CA1806.severity = warning + +# CA1810: Initialize reference type static fields inline +dotnet_diagnostic.CA1810.severity = warning + +# CA1812: Avoid uninstantiated internal classes +dotnet_diagnostic.CA1812.severity = warning + +# CA1813: Avoid unsealed attributes +dotnet_diagnostic.CA1813.severity = warning + +# CA1814: Prefer jagged arrays over multidimensional +dotnet_diagnostic.CA1814.severity = warning + +# CA1815: Override equals and operator equals on value types +dotnet_diagnostic.CA1815.severity = warning + +# CA1816: Dispose methods should call SuppressFinalize +dotnet_diagnostic.CA1816.severity = warning + +# CA1819: Properties should not return arrays +dotnet_diagnostic.CA1819.severity = warning + +# CA1820: Test for empty strings using string length +dotnet_diagnostic.CA1820.severity = warning + +# CA1821: Remove empty Finalizers +dotnet_diagnostic.CA1821.severity = warning + +# CA1822: Mark members as static +dotnet_diagnostic.CA1822.severity = warning + +# CA1823: Avoid unused private fields +dotnet_diagnostic.CA1823.severity = warning + +# CA1824: Mark assemblies with NeutralResourcesLanguageAttribute +dotnet_diagnostic.CA1824.severity = warning + +# CA1825: Avoid zero-length array allocations +dotnet_diagnostic.CA1825.severity = warning + +# CA1826: Do not use Enumerable methods on indexable collections +dotnet_diagnostic.CA1826.severity = warning + +# CA1827: Do not use Count() or LongCount() when Any() can be used +dotnet_diagnostic.CA1827.severity = warning + +# CA1828: Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used +dotnet_diagnostic.CA1828.severity = warning + +# CA1829: Use Length/Count property instead of Count() when available +dotnet_diagnostic.CA1829.severity = warning + +# CA1830: Prefer strongly-typed Append and Insert method overloads on StringBuilder +dotnet_diagnostic.CA1830.severity = warning + +# CA1831: Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1831.severity = warning + +# CA1832: Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1832.severity = warning + +# CA1833: Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1833.severity = warning + +# CA1834: Consider using 'StringBuilder.Append(char)' when applicable +dotnet_diagnostic.CA1834.severity = warning + +# CA1835: Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync' +dotnet_diagnostic.CA1835.severity = warning + +# CA1836: Prefer IsEmpty over Count +dotnet_diagnostic.CA1836.severity = warning + +# CA1837: Use 'Environment.ProcessId' +dotnet_diagnostic.CA1837.severity = warning + +# CA1838: Avoid 'StringBuilder' parameters for P/Invokes +dotnet_diagnostic.CA1838.severity = warning + +# CA1839: Use 'Environment.ProcessPath' +dotnet_diagnostic.CA1839.severity = warning + +# CA1840: Use 'Environment.CurrentManagedThreadId' +dotnet_diagnostic.CA1840.severity = warning + +# CA1841: Prefer Dictionary.Contains methods +dotnet_diagnostic.CA1841.severity = warning + +# CA1842: Do not use 'WhenAll' with a single task +dotnet_diagnostic.CA1842.severity = warning + +# CA1843: Do not use 'WaitAll' with a single task +dotnet_diagnostic.CA1843.severity = warning + +# CA1844: Provide memory-based overrides of async methods when subclassing 'Stream' +dotnet_diagnostic.CA1844.severity = warning + +# CA1845: Use span-based 'string.Concat' +dotnet_diagnostic.CA1845.severity = warning + +# CA1846: Prefer 'AsSpan' over 'Substring' +dotnet_diagnostic.CA1846.severity = warning + +# CA1847: Use char literal for a single character lookup +dotnet_diagnostic.CA1847.severity = warning + +# CA1848: Use the LoggerMessage delegates +dotnet_diagnostic.CA1848.severity = warning + +# CA1849: Call async methods when in an async method +dotnet_diagnostic.CA1849.severity = warning + +# CA1850: Prefer static 'HashData' method over 'ComputeHash' +dotnet_diagnostic.CA1850.severity = warning + +# CA1851: Possible multiple enumerations of 'IEnumerable' collection +dotnet_diagnostic.CA1851.severity = warning + +# CA1852: Seal internal types +dotnet_diagnostic.CA1852.severity = warning + +# CA1853: Unnecessary call to 'Dictionary.ContainsKey(key)' +dotnet_diagnostic.CA1853.severity = warning + +# CA1854: Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method +dotnet_diagnostic.CA1854.severity = warning + +# CA1855: Prefer 'Clear' over 'Fill' +dotnet_diagnostic.CA1855.severity = warning + +# CA1856: Incorrect usage of ConstantExpected attribute +dotnet_diagnostic.CA1856.severity = warning + +# CA1857: A constant is expected for the parameter +dotnet_diagnostic.CA1857.severity = warning + +# CA1858: Use 'StartsWith' instead of 'IndexOf' +dotnet_diagnostic.CA1858.severity = warning + +# CA1859: Use concrete types when possible for improved performance +dotnet_diagnostic.CA1859.severity = warning + +# CA1860: Avoid using 'Enumerable.Any()' extension method +dotnet_diagnostic.CA1860.severity = warning + +# CA1861: Avoid constant arrays as arguments +dotnet_diagnostic.CA1861.severity = warning + +# CA1862: Use the 'StringComparison' method overloads to perform case-insensitive string comparisons +dotnet_diagnostic.CA1862.severity = warning + +# CA1863: Use 'CompositeFormat' +dotnet_diagnostic.CA1863.severity = warning + +# CA1864: Prefer the 'IDictionary.TryAdd(TKey, TValue)' method +dotnet_diagnostic.CA1864.severity = warning + +# CA1865: Use char overload +dotnet_diagnostic.CA1865.severity = warning + +# CA1866: Use char overload +dotnet_diagnostic.CA1866.severity = warning + +# CA1867: Use char overload +dotnet_diagnostic.CA1867.severity = warning + +# CA1868: Unnecessary call to 'Contains(item)' +dotnet_diagnostic.CA1868.severity = warning + +# CA1869: Cache and reuse 'JsonSerializerOptions' instances +dotnet_diagnostic.CA1869.severity = warning + +# CA1870: Use a cached 'SearchValues' instance +dotnet_diagnostic.CA1870.severity = warning + +# CA2000: Dispose objects before losing scope +dotnet_diagnostic.CA2000.severity = warning + +# CA2002: Do not lock on objects with weak identity +dotnet_diagnostic.CA2002.severity = warning + +# CA2007: Consider calling ConfigureAwait on the awaited task +dotnet_diagnostic.CA2007.severity = warning + +# CA2008: Do not create tasks without passing a TaskScheduler +dotnet_diagnostic.CA2008.severity = warning + +# CA2009: Do not call ToImmutableCollection on an ImmutableCollection value +dotnet_diagnostic.CA2009.severity = warning + +# CA2011: Avoid infinite recursion +dotnet_diagnostic.CA2011.severity = warning + +# CA2012: Use ValueTasks correctly +dotnet_diagnostic.CA2012.severity = warning + +# CA2013: Do not use ReferenceEquals with value types +dotnet_diagnostic.CA2013.severity = warning + +# CA2014: Do not use stackalloc in loops +dotnet_diagnostic.CA2014.severity = warning + +# CA2015: Do not define finalizers for types derived from MemoryManager +dotnet_diagnostic.CA2015.severity = warning + +# CA2016: Forward the 'CancellationToken' parameter to methods +dotnet_diagnostic.CA2016.severity = warning + +# CA2017: Parameter count mismatch +dotnet_diagnostic.CA2017.severity = warning + +# CA2018: 'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument +dotnet_diagnostic.CA2018.severity = warning + +# CA2019: Improper 'ThreadStatic' field initialization +dotnet_diagnostic.CA2019.severity = warning + +# CA2020: Prevent behavioral change +dotnet_diagnostic.CA2020.severity = warning + +# CA2021: Do not call Enumerable.Cast or Enumerable.OfType with incompatible types +dotnet_diagnostic.CA2021.severity = warning + +# CA2100: Review SQL queries for security vulnerabilities +dotnet_diagnostic.CA2100.severity = warning + +# CA2101: Specify marshaling for P/Invoke string arguments +dotnet_diagnostic.CA2101.severity = warning + +# CA2119: Seal methods that satisfy private interfaces +dotnet_diagnostic.CA2119.severity = warning + +# CA2153: Do Not Catch Corrupted State Exceptions +dotnet_diagnostic.CA2153.severity = warning + +# CA2200: Rethrow to preserve stack details +dotnet_diagnostic.CA2200.severity = warning + +# CA2201: Do not raise reserved exception types +dotnet_diagnostic.CA2201.severity = warning + +# CA2207: Initialize value type static fields inline +dotnet_diagnostic.CA2207.severity = warning + +# CA2208: Instantiate argument exceptions correctly +dotnet_diagnostic.CA2208.severity = warning + +# CA2211: Non-constant fields should not be visible +dotnet_diagnostic.CA2211.severity = warning + +# CA2213: Disposable fields should be disposed +dotnet_diagnostic.CA2213.severity = warning + +# CA2214: Do not call overridable methods in constructors +dotnet_diagnostic.CA2214.severity = warning + +# CA2215: Dispose methods should call base class dispose +dotnet_diagnostic.CA2215.severity = warning + +# CA2216: Disposable types should declare finalizer +dotnet_diagnostic.CA2216.severity = warning + +# CA2217: Do not mark enums with FlagsAttribute +dotnet_diagnostic.CA2217.severity = warning + +# CA2218: Override GetHashCode on overriding Equals +dotnet_diagnostic.CA2218.severity = warning + +# CA2219: Do not raise exceptions in finally clauses +dotnet_diagnostic.CA2219.severity = warning + +# CA2224: Override Equals on overloading operator equals +dotnet_diagnostic.CA2224.severity = warning + +# CA2225: Operator overloads have named alternates +dotnet_diagnostic.CA2225.severity = warning + +# CA2226: Operators should have symmetrical overloads +dotnet_diagnostic.CA2226.severity = warning + +# CA2227: Collection properties should be read only +dotnet_diagnostic.CA2227.severity = warning + +# CA2231: Overload operator equals on overriding value type Equals +dotnet_diagnostic.CA2231.severity = warning + +# CA2234: Pass system uri objects instead of strings +dotnet_diagnostic.CA2234.severity = warning + +# CA2235: Mark all non-serializable fields +dotnet_diagnostic.CA2235.severity = warning + +# CA2237: Mark ISerializable types with serializable +dotnet_diagnostic.CA2237.severity = warning + +# CA2241: Provide correct arguments to formatting methods +dotnet_diagnostic.CA2241.severity = warning + +# CA2242: Test for NaN correctly +dotnet_diagnostic.CA2242.severity = warning + +# CA2243: Attribute string literals should parse correctly +dotnet_diagnostic.CA2243.severity = warning + +# CA2244: Do not duplicate indexed element initializations +dotnet_diagnostic.CA2244.severity = warning + +# CA2245: Do not assign a property to itself +dotnet_diagnostic.CA2245.severity = warning + +# CA2246: Assigning symbol and its member in the same statement +dotnet_diagnostic.CA2246.severity = warning + +# CA2247: Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum +dotnet_diagnostic.CA2247.severity = warning + +# CA2248: Provide correct 'enum' argument to 'Enum.HasFlag' +dotnet_diagnostic.CA2248.severity = warning + +# CA2249: Consider using 'string.Contains' instead of 'string.IndexOf' +dotnet_diagnostic.CA2249.severity = warning + +# CA2250: Use 'ThrowIfCancellationRequested' +dotnet_diagnostic.CA2250.severity = warning + +# CA2251: Use 'string.Equals' +dotnet_diagnostic.CA2251.severity = warning + +# CA2252: This API requires opting into preview features +dotnet_diagnostic.CA2252.severity = warning + +# CA2253: Named placeholders should not be numeric values +dotnet_diagnostic.CA2253.severity = warning + +# CA2254: Template should be a static expression +dotnet_diagnostic.CA2254.severity = warning + +# CA2255: The 'ModuleInitializer' attribute should not be used in libraries +dotnet_diagnostic.CA2255.severity = warning + +# CA2256: All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface +dotnet_diagnostic.CA2256.severity = warning + +# CA2257: Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static' +dotnet_diagnostic.CA2257.severity = warning + +# CA2258: Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported +dotnet_diagnostic.CA2258.severity = warning + +# CA2259: 'ThreadStatic' only affects static fields +dotnet_diagnostic.CA2259.severity = warning + +# CA2260: Use correct type parameter +dotnet_diagnostic.CA2260.severity = warning + +# CA2261: Do not use ConfigureAwaitOptions.SuppressThrowing with Task +dotnet_diagnostic.CA2261.severity = warning + +# CA2300: Do not use insecure deserializer BinaryFormatter +dotnet_diagnostic.CA2300.severity = warning + +# CA2301: Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder +dotnet_diagnostic.CA2301.severity = warning + +# CA2302: Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize +dotnet_diagnostic.CA2302.severity = warning + +# CA2305: Do not use insecure deserializer LosFormatter +dotnet_diagnostic.CA2305.severity = warning + +# CA2310: Do not use insecure deserializer NetDataContractSerializer +dotnet_diagnostic.CA2310.severity = warning + +# CA2311: Do not deserialize without first setting NetDataContractSerializer.Binder +dotnet_diagnostic.CA2311.severity = warning + +# CA2312: Ensure NetDataContractSerializer.Binder is set before deserializing +dotnet_diagnostic.CA2312.severity = warning + +# CA2315: Do not use insecure deserializer ObjectStateFormatter +dotnet_diagnostic.CA2315.severity = warning + +# CA2321: Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver +dotnet_diagnostic.CA2321.severity = warning + +# CA2322: Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing +dotnet_diagnostic.CA2322.severity = warning + +# CA2326: Do not use TypeNameHandling values other than None +dotnet_diagnostic.CA2326.severity = warning + +# CA2327: Do not use insecure JsonSerializerSettings +dotnet_diagnostic.CA2327.severity = warning + +# CA2328: Ensure that JsonSerializerSettings are secure +dotnet_diagnostic.CA2328.severity = warning + +# CA2329: Do not deserialize with JsonSerializer using an insecure configuration +dotnet_diagnostic.CA2329.severity = warning + +# CA2330: Ensure that JsonSerializer has a secure configuration when deserializing +dotnet_diagnostic.CA2330.severity = warning + +# CA2350: Do not use DataTable.ReadXml() with untrusted data +dotnet_diagnostic.CA2350.severity = warning + +# CA2351: Do not use DataSet.ReadXml() with untrusted data +dotnet_diagnostic.CA2351.severity = warning + +# CA2352: Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks +dotnet_diagnostic.CA2352.severity = warning + +# CA2353: Unsafe DataSet or DataTable in serializable type +dotnet_diagnostic.CA2353.severity = warning + +# CA2354: Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attacks +dotnet_diagnostic.CA2354.severity = warning + +# CA2355: Unsafe DataSet or DataTable type found in deserializable object graph +dotnet_diagnostic.CA2355.severity = warning + +# CA2356: Unsafe DataSet or DataTable type in web deserializable object graph +dotnet_diagnostic.CA2356.severity = warning + +# CA2361: Ensure auto-generated class containing DataSet.ReadXml() is not used with untrusted data +dotnet_diagnostic.CA2361.severity = warning + +# CA2362: Unsafe DataSet or DataTable in auto-generated serializable type can be vulnerable to remote code execution attacks +dotnet_diagnostic.CA2362.severity = warning + +# CA3001: Review code for SQL injection vulnerabilities +dotnet_diagnostic.CA3001.severity = warning + +# CA3002: Review code for XSS vulnerabilities +dotnet_diagnostic.CA3002.severity = warning + +# CA3003: Review code for file path injection vulnerabilities +dotnet_diagnostic.CA3003.severity = warning + +# CA3004: Review code for information disclosure vulnerabilities +dotnet_diagnostic.CA3004.severity = warning + +# CA3005: Review code for LDAP injection vulnerabilities +dotnet_diagnostic.CA3005.severity = warning + +# CA3006: Review code for process command injection vulnerabilities +dotnet_diagnostic.CA3006.severity = warning + +# CA3007: Review code for open redirect vulnerabilities +dotnet_diagnostic.CA3007.severity = warning + +# CA3008: Review code for XPath injection vulnerabilities +dotnet_diagnostic.CA3008.severity = warning + +# CA3009: Review code for XML injection vulnerabilities +dotnet_diagnostic.CA3009.severity = warning + +# CA3010: Review code for XAML injection vulnerabilities +dotnet_diagnostic.CA3010.severity = warning + +# CA3011: Review code for DLL injection vulnerabilities +dotnet_diagnostic.CA3011.severity = warning + +# CA3012: Review code for regex injection vulnerabilities +dotnet_diagnostic.CA3012.severity = warning + +# CA3061: Do Not Add Schema By URL +dotnet_diagnostic.CA3061.severity = warning + +# CA3075: Insecure DTD processing in XML +dotnet_diagnostic.CA3075.severity = warning + +# CA3076: Insecure XSLT script processing +dotnet_diagnostic.CA3076.severity = warning + +# CA3077: Insecure Processing in API Design, XmlDocument and XmlTextReader +dotnet_diagnostic.CA3077.severity = warning + +# CA3147: Mark Verb Handlers With Validate Antiforgery Token +dotnet_diagnostic.CA3147.severity = warning + +# CA5350: Do Not Use Weak Cryptographic Algorithms +dotnet_diagnostic.CA5350.severity = warning + +# CA5351: Do Not Use Broken Cryptographic Algorithms +dotnet_diagnostic.CA5351.severity = warning + +# CA5358: Review cipher mode usage with cryptography experts +dotnet_diagnostic.CA5358.severity = warning + +# CA5359: Do Not Disable Certificate Validation +dotnet_diagnostic.CA5359.severity = warning + +# CA5360: Do Not Call Dangerous Methods In Deserialization +dotnet_diagnostic.CA5360.severity = warning + +# CA5361: Do Not Disable SChannel Use of Strong Crypto +dotnet_diagnostic.CA5361.severity = warning + +# CA5362: Potential reference cycle in deserialized object graph +dotnet_diagnostic.CA5362.severity = warning + +# CA5363: Do Not Disable Request Validation +dotnet_diagnostic.CA5363.severity = warning + +# CA5364: Do Not Use Deprecated Security Protocols +dotnet_diagnostic.CA5364.severity = warning + +# CA5365: Do Not Disable HTTP Header Checking +dotnet_diagnostic.CA5365.severity = warning + +# CA5366: Use XmlReader for 'DataSet.ReadXml()' +dotnet_diagnostic.CA5366.severity = warning + +# CA5367: Do Not Serialize Types With Pointer Fields +dotnet_diagnostic.CA5367.severity = warning + +# CA5368: Set ViewStateUserKey For Classes Derived From Page +dotnet_diagnostic.CA5368.severity = warning + +# CA5369: Use XmlReader for 'XmlSerializer.Deserialize()' +dotnet_diagnostic.CA5369.severity = warning + +# CA5370: Use XmlReader for XmlValidatingReader constructor +dotnet_diagnostic.CA5370.severity = warning + +# CA5371: Use XmlReader for 'XmlSchema.Read()' +dotnet_diagnostic.CA5371.severity = warning + +# CA5372: Use XmlReader for XPathDocument constructor +dotnet_diagnostic.CA5372.severity = warning + +# CA5373: Do not use obsolete key derivation function +dotnet_diagnostic.CA5373.severity = warning + +# CA5374: Do Not Use XslTransform +dotnet_diagnostic.CA5374.severity = warning + +# CA5375: Do Not Use Account Shared Access Signature +dotnet_diagnostic.CA5375.severity = warning + +# CA5376: Use SharedAccessProtocol HttpsOnly +dotnet_diagnostic.CA5376.severity = warning + +# CA5377: Use Container Level Access Policy +dotnet_diagnostic.CA5377.severity = warning + +# CA5378: Do not disable ServicePointManagerSecurityProtocols +dotnet_diagnostic.CA5378.severity = warning + +# CA5379: Ensure Key Derivation Function algorithm is sufficiently strong +dotnet_diagnostic.CA5379.severity = warning + +# CA5380: Do Not Add Certificates To Root Store +dotnet_diagnostic.CA5380.severity = warning + +# CA5381: Ensure Certificates Are Not Added To Root Store +dotnet_diagnostic.CA5381.severity = warning + +# CA5382: Use Secure Cookies In ASP.NET Core +dotnet_diagnostic.CA5382.severity = warning + +# CA5383: Ensure Use Secure Cookies In ASP.NET Core +dotnet_diagnostic.CA5383.severity = warning + +# CA5384: Do Not Use Digital Signature Algorithm (DSA) +dotnet_diagnostic.CA5384.severity = warning + +# CA5385: Use Rivest-Shamir-Adleman (RSA) Algorithm With Sufficient Key Size +dotnet_diagnostic.CA5385.severity = warning + +# CA5386: Avoid hardcoding SecurityProtocolType value +dotnet_diagnostic.CA5386.severity = warning + +# CA5387: Do Not Use Weak Key Derivation Function With Insufficient Iteration Count +dotnet_diagnostic.CA5387.severity = warning + +# CA5388: Ensure Sufficient Iteration Count When Using Weak Key Derivation Function +dotnet_diagnostic.CA5388.severity = warning + +# CA5389: Do Not Add Archive Item's Path To The Target File System Path +dotnet_diagnostic.CA5389.severity = warning + +# CA5390: Do not hard-code encryption key +dotnet_diagnostic.CA5390.severity = warning + +# CA5391: Use antiforgery tokens in ASP.NET Core MVC controllers +dotnet_diagnostic.CA5391.severity = warning + +# CA5392: Use DefaultDllImportSearchPaths attribute for P/Invokes +dotnet_diagnostic.CA5392.severity = warning + +# CA5393: Do not use unsafe DllImportSearchPath value +dotnet_diagnostic.CA5393.severity = warning + +# CA5394: Do not use insecure randomness +dotnet_diagnostic.CA5394.severity = warning + +# CA5395: Miss HttpVerb attribute for action methods +dotnet_diagnostic.CA5395.severity = warning + +# CA5396: Set HttpOnly to true for HttpCookie +dotnet_diagnostic.CA5396.severity = warning + +# CA5397: Do not use deprecated SslProtocols values +dotnet_diagnostic.CA5397.severity = warning + +# CA5398: Avoid hardcoded SslProtocols values +dotnet_diagnostic.CA5398.severity = warning + +# CA5399: HttpClients should enable certificate revocation list checks +dotnet_diagnostic.CA5399.severity = warning + +# CA5400: Ensure HttpClient certificate revocation list check is not disabled +dotnet_diagnostic.CA5400.severity = warning + +# CA5401: Do not use CreateEncryptor with non-default IV +dotnet_diagnostic.CA5401.severity = warning + +# CA5402: Use CreateEncryptor with the default IV +dotnet_diagnostic.CA5402.severity = warning + +# CA5403: Do not hard-code certificate +dotnet_diagnostic.CA5403.severity = warning + +# CA5404: Do not disable token validation checks +dotnet_diagnostic.CA5404.severity = warning + +# CA5405: Do not always skip token validation in delegates +dotnet_diagnostic.CA5405.severity = warning + +[*.{cs,vb}] +#### Naming styles #### + +# Naming rules + +dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion +dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface +dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i + +dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.types_should_be_pascal_case.symbols = types +dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case + +dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members +dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case + +# Symbol specifications + +dotnet_naming_symbols.interface.applicable_kinds = interface +dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.interface.required_modifiers = + +dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum +dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.types.required_modifiers = + +dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method +dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.non_field_members.required_modifiers = + +# Naming styles + +dotnet_naming_style.begins_with_i.required_prefix = I +dotnet_naming_style.begins_with_i.required_suffix = +dotnet_naming_style.begins_with_i.word_separator = +dotnet_naming_style.begins_with_i.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case +dotnet_style_operator_placement_when_wrapping = beginning_of_line +tab_width = 4 +indent_size = 4 +end_of_line = crlf +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_auto_properties = true:silent +dotnet_style_object_initializer = true:suggestion +dotnet_style_prefer_collection_expression = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_compound_assignment = true:suggestion +dotnet_style_prefer_simplified_interpolation = true:suggestion +dotnet_style_namespace_match_folder = true:suggestion + +[*.cs] +csharp_indent_labels = one_less_than_current +csharp_space_around_binary_operators = before_and_after +csharp_using_directive_placement = outside_namespace:silent +csharp_prefer_simple_using_statement = true:suggestion +csharp_prefer_braces = true:silent +csharp_style_namespace_declarations = block_scoped:silent +csharp_style_prefer_method_group_conversion = true:silent +csharp_style_prefer_top_level_statements = true:silent +csharp_style_prefer_primary_constructors = true:suggestion +csharp_style_expression_bodied_methods = false:silent +csharp_style_expression_bodied_constructors = false:silent +csharp_style_expression_bodied_operators = false:silent +csharp_style_expression_bodied_properties = true:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_accessors = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = false:silent +csharp_style_throw_expression = true:suggestion +csharp_style_prefer_null_check_over_type_check = true:suggestion +csharp_prefer_simple_default_expression = true:suggestion +csharp_style_prefer_local_over_anonymous_function = true:suggestion +csharp_style_prefer_index_operator = true:suggestion +csharp_style_prefer_range_operator = true:suggestion +csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion +csharp_style_prefer_tuple_swap = true:suggestion +csharp_style_prefer_utf8_string_literals = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_deconstructed_variable_declaration = true:suggestion +csharp_style_unused_value_assignment_preference = discard_variable:suggestion +csharp_style_unused_value_expression_statement_preference = discard_variable:silent diff --git a/Influx/AllaganTools/AllaganToolsIpc.cs b/Influx/AllaganTools/AllaganToolsIpc.cs index 9c2b744..04d054e 100644 --- a/Influx/AllaganTools/AllaganToolsIpc.cs +++ b/Influx/AllaganTools/AllaganToolsIpc.cs @@ -15,13 +15,12 @@ internal sealed class AllaganToolsIpc : IDisposable private readonly DalamudReflector _dalamudReflector; private readonly IFramework _framework; private readonly IPluginLog _pluginLog; - private readonly ICallGateSubscriber? _initialized; - private readonly ICallGateSubscriber? _isInitialized; + private readonly ICallGateSubscriber _initialized; private readonly ICallGateSubscriber> _getSearchFilters; - public ICharacterMonitor Characters { get; private set; } = new UnavailableCharacterMonitor(); - public IInventoryMonitor Inventories { get; private set; } = new UnavailableInventoryMonitor(); - public IFilterService Filters { get; set; } = new UnavailableFilterService(); + private ICharacterMonitor _characters; + private IInventoryMonitor _inventories; + private IFilterService _filters; public AllaganToolsIpc(DalamudPluginInterface pluginInterface, IChatGui chatGui, DalamudReflector dalamudReflector, IFramework framework, IPluginLog pluginLog) @@ -32,14 +31,20 @@ internal sealed class AllaganToolsIpc : IDisposable _pluginLog = pluginLog; _initialized = pluginInterface.GetIpcSubscriber("AllaganTools.Initialized"); - _isInitialized = pluginInterface.GetIpcSubscriber("AllaganTools.IsInitialized"); - _initialized.Subscribe(ConfigureIpc); _getSearchFilters = pluginInterface.GetIpcSubscriber>("AllaganTools.GetSearchFilters"); + _characters = new UnavailableCharacterMonitor(_pluginLog); + _inventories = new UnavailableInventoryMonitor(_pluginLog); + _filters = new UnavailableFilterService(_pluginLog); + + _initialized.Subscribe(ConfigureIpc); + try { - bool isInitialized = _isInitialized.InvokeFunc(); + ICallGateSubscriber isInitializedFunc = + pluginInterface.GetIpcSubscriber("AllaganTools.IsInitialized"); + bool isInitialized = isInitializedFunc.InvokeFunc(); if (isInitialized) ConfigureIpc(true); } @@ -60,10 +65,10 @@ internal sealed class AllaganToolsIpc : IDisposable { var pluginService = it.GetType().Assembly.GetType("InventoryTools.PluginService")!; - Characters = new CharacterMonitor(pluginService.GetProperty("CharacterMonitor")!.GetValue(null)!); - Inventories = new InventoryMonitor( + _characters = new CharacterMonitor(pluginService.GetProperty("CharacterMonitor")!.GetValue(null)!); + _inventories = new InventoryMonitor( pluginService.GetProperty("InventoryMonitor")!.GetValue(null)!); - Filters = new FilterService(pluginService.GetProperty("FilterService")!.GetValue(null)!); + _filters = new FilterService(pluginService.GetProperty("FilterService")!.GetValue(null)!); } else { @@ -95,7 +100,7 @@ internal sealed class AllaganToolsIpc : IDisposable { try { - return Filters.GetFilterByKeyOrName(keyOrName); + return _filters.GetFilterByKeyOrName(keyOrName); } catch (IpcError e) { @@ -106,9 +111,9 @@ internal sealed class AllaganToolsIpc : IDisposable public Dictionary CountCurrencies() { - _pluginLog.Debug($"{Characters.GetType()}, {Inventories.GetType()}"); - var characters = Characters.All.ToDictionary(x => x.CharacterId, x => x); - return Inventories.All + _pluginLog.Debug($"{_characters.GetType()}, {_inventories.GetType()}"); + var characters = _characters.All.ToDictionary(x => x.CharacterId, x => x); + return _inventories.All .Where(x => characters.ContainsKey(x.Value.CharacterId)) .ToDictionary( x => characters[x.Value.CharacterId], @@ -130,21 +135,14 @@ internal sealed class AllaganToolsIpc : IDisposable public void Dispose() { - _initialized?.Unsubscribe(ConfigureIpc); - Characters = new UnavailableCharacterMonitor(); - Inventories = new UnavailableInventoryMonitor(); - Filters = new UnavailableFilterService(); + _initialized.Unsubscribe(ConfigureIpc); + _characters = new UnavailableCharacterMonitor(_pluginLog); + _inventories = new UnavailableInventoryMonitor(_pluginLog); + _filters = new UnavailableFilterService(_pluginLog); } - private sealed class InventoryWrapper + private sealed class InventoryWrapper(IEnumerable items) { - private readonly IEnumerable _items; - - public InventoryWrapper(IEnumerable items) - { - _items = items; - } - - public long Sum(int itemId) => _items.Where(x => x.ItemId == itemId).Sum(x => x.Quantity); + public long Sum(int itemId) => items.Where(x => x.ItemId == itemId).Sum(x => x.Quantity); } } diff --git a/Influx/AllaganTools/Character.cs b/Influx/AllaganTools/Character.cs index 01d4e34..8d85d74 100644 --- a/Influx/AllaganTools/Character.cs +++ b/Influx/AllaganTools/Character.cs @@ -1,3 +1,4 @@ +using System; using System.Reflection; namespace Influx.AllaganTools; @@ -10,6 +11,7 @@ internal sealed class Character public Character(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _name = _delegate.GetType().GetField("Name")!; _level = _delegate.GetType().GetField("Level")!; diff --git a/Influx/AllaganTools/CharacterMonitor.cs b/Influx/AllaganTools/CharacterMonitor.cs index cf69e96..a166632 100644 --- a/Influx/AllaganTools/CharacterMonitor.cs +++ b/Influx/AllaganTools/CharacterMonitor.cs @@ -14,6 +14,7 @@ internal sealed class CharacterMonitor : ICharacterMonitor public CharacterMonitor(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _getPlayerCharacters = _delegate.GetType().GetMethod("GetPlayerCharacters")!; _allCharacters = _delegate.GetType().GetMethod("AllCharacters")!; @@ -22,7 +23,7 @@ internal sealed class CharacterMonitor : ICharacterMonitor public IEnumerable PlayerCharacters => GetCharactersInternal(_getPlayerCharacters); public IEnumerable All => GetCharactersInternal(_allCharacters); - private IEnumerable GetCharactersInternal(MethodInfo methodInfo) + private List GetCharactersInternal(MethodInfo methodInfo) { return ((IEnumerable)methodInfo.Invoke(_delegate, Array.Empty())!) .Cast() diff --git a/Influx/AllaganTools/Filter.cs b/Influx/AllaganTools/Filter.cs index 8563d4c..f6c5510 100644 --- a/Influx/AllaganTools/Filter.cs +++ b/Influx/AllaganTools/Filter.cs @@ -1,4 +1,5 @@ -using System.Collections; +using System; +using System.Collections; using System.Collections.Generic; using System.Linq; using System.Reflection; @@ -13,6 +14,7 @@ internal sealed class Filter public Filter(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _generateFilteredList = _delegate.GetType().GetMethod("GenerateFilteredList")!; } diff --git a/Influx/AllaganTools/FilterService.cs b/Influx/AllaganTools/FilterService.cs index 3fee3f7..f32ddba 100644 --- a/Influx/AllaganTools/FilterService.cs +++ b/Influx/AllaganTools/FilterService.cs @@ -1,4 +1,5 @@ -using System.Reflection; +using System; +using System.Reflection; namespace Influx.AllaganTools; @@ -9,13 +10,14 @@ internal sealed class FilterService : IFilterService public FilterService(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _getFilterByKeyOrName = _delegate.GetType().GetMethod("GetFilterByKeyOrName")!; } public Filter? GetFilterByKeyOrName(string keyOrName) { - var f = _getFilterByKeyOrName.Invoke(_delegate, new object?[] { keyOrName }); + var f = _getFilterByKeyOrName.Invoke(_delegate, [keyOrName]); return f != null ? new Filter(f) : null; } } diff --git a/Influx/AllaganTools/Inventory.cs b/Influx/AllaganTools/Inventory.cs index 449e353..0028dbd 100644 --- a/Influx/AllaganTools/Inventory.cs +++ b/Influx/AllaganTools/Inventory.cs @@ -13,6 +13,7 @@ internal sealed class Inventory public Inventory(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _getAllInventories = _delegate.GetType().GetMethod("GetAllInventories")!; CharacterId = (ulong)_delegate.GetType().GetProperty("CharacterId")!.GetValue(_delegate)!; diff --git a/Influx/AllaganTools/InventoryItem.cs b/Influx/AllaganTools/InventoryItem.cs index b640b17..b9e8780 100644 --- a/Influx/AllaganTools/InventoryItem.cs +++ b/Influx/AllaganTools/InventoryItem.cs @@ -1,14 +1,14 @@ -namespace Influx.AllaganTools; +using System; + +namespace Influx.AllaganTools; internal sealed class InventoryItem { - private readonly object _delegate; - public InventoryItem(object @delegate) { - _delegate = @delegate; - ItemId = (uint)_delegate.GetType().GetField("ItemId")!.GetValue(_delegate)!; - Quantity = (uint)_delegate.GetType().GetField("Quantity")!.GetValue(_delegate)!; + ArgumentNullException.ThrowIfNull(@delegate); + ItemId = (uint)@delegate.GetType().GetField("ItemId")!.GetValue(@delegate)!; + Quantity = (uint)@delegate.GetType().GetField("Quantity")!.GetValue(@delegate)!; } public uint ItemId { get; } diff --git a/Influx/AllaganTools/InventoryMonitor.cs b/Influx/AllaganTools/InventoryMonitor.cs index eb40780..c42b03e 100644 --- a/Influx/AllaganTools/InventoryMonitor.cs +++ b/Influx/AllaganTools/InventoryMonitor.cs @@ -1,4 +1,5 @@ -using System.Collections; +using System; +using System.Collections; using System.Collections.Generic; using System.Linq; using System.Reflection; @@ -12,6 +13,7 @@ internal sealed class InventoryMonitor : IInventoryMonitor public InventoryMonitor(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); _delegate = @delegate; _inventories = _delegate.GetType().GetProperty("Inventories")!; } diff --git a/Influx/AllaganTools/SortingResult.cs b/Influx/AllaganTools/SortingResult.cs index ce1a4d2..3c044d6 100644 --- a/Influx/AllaganTools/SortingResult.cs +++ b/Influx/AllaganTools/SortingResult.cs @@ -1,10 +1,14 @@ -namespace Influx.AllaganTools; +using System; + +namespace Influx.AllaganTools; using ItemFlags = FFXIVClientStructs.FFXIV.Client.Game.InventoryItem.ItemFlags; internal sealed class SortingResult { public SortingResult(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); + LocalContentId = (ulong)@delegate.GetType().GetProperty("SourceRetainerId")!.GetValue(@delegate)!; Quantity = (int)@delegate.GetType().GetProperty("Quantity")!.GetValue(@delegate)!; diff --git a/Influx/AllaganTools/UnavailableCharacterMonitor.cs b/Influx/AllaganTools/UnavailableCharacterMonitor.cs index 1f43961..4836f07 100644 --- a/Influx/AllaganTools/UnavailableCharacterMonitor.cs +++ b/Influx/AllaganTools/UnavailableCharacterMonitor.cs @@ -1,10 +1,26 @@ using System; using System.Collections.Generic; +using Dalamud.Plugin.Services; namespace Influx.AllaganTools; -internal sealed class UnavailableCharacterMonitor : ICharacterMonitor +internal sealed class UnavailableCharacterMonitor(IPluginLog pluginLog) : ICharacterMonitor { - public IEnumerable PlayerCharacters => Array.Empty(); - public IEnumerable All => Array.Empty(); + public IEnumerable PlayerCharacters + { + get + { + pluginLog.Warning("Character monitor is unavailable"); + return Array.Empty(); + } + } + + public IEnumerable All + { + get + { + pluginLog.Warning("Character monitor is unavailable"); + return Array.Empty(); + } + } } diff --git a/Influx/AllaganTools/UnavailableFilterService.cs b/Influx/AllaganTools/UnavailableFilterService.cs index ebbf3a9..08e4269 100644 --- a/Influx/AllaganTools/UnavailableFilterService.cs +++ b/Influx/AllaganTools/UnavailableFilterService.cs @@ -1,6 +1,12 @@ -namespace Influx.AllaganTools; +using Dalamud.Plugin.Services; -internal sealed class UnavailableFilterService : IFilterService +namespace Influx.AllaganTools; + +internal sealed class UnavailableFilterService(IPluginLog pluginLog) : IFilterService { - public Filter? GetFilterByKeyOrName(string keyOrName) => null; + public Filter? GetFilterByKeyOrName(string keyOrName) + { + pluginLog.Warning("Filter Service is unavailable"); + return null; + } } diff --git a/Influx/AllaganTools/UnavailableInventoryMonitor.cs b/Influx/AllaganTools/UnavailableInventoryMonitor.cs index 771c411..8fa30ec 100644 --- a/Influx/AllaganTools/UnavailableInventoryMonitor.cs +++ b/Influx/AllaganTools/UnavailableInventoryMonitor.cs @@ -1,8 +1,16 @@ using System.Collections.Generic; +using Dalamud.Plugin.Services; namespace Influx.AllaganTools; -internal sealed class UnavailableInventoryMonitor : IInventoryMonitor +internal sealed class UnavailableInventoryMonitor(IPluginLog pluginLog) : IInventoryMonitor { - public IReadOnlyDictionary All => new Dictionary(); + public IReadOnlyDictionary All + { + get + { + pluginLog.Warning("Inventory monitor is unavailable"); + return new Dictionary(); + } + } } diff --git a/Influx/Configuration.cs b/Influx/Configuration.cs index 8a6cf10..a6de808 100644 --- a/Influx/Configuration.cs +++ b/Influx/Configuration.cs @@ -3,14 +3,14 @@ using Dalamud.Configuration; namespace Influx; -public sealed class Configuration : IPluginConfiguration +internal sealed class Configuration : IPluginConfiguration { public int Version { get; set; } = 1; public ServerConfiguration Server { get; set; } = new(); - public List IncludedCharacters { get; set; } = new(); - public List IncludedInventoryFilters { get; set; } = new(); + public IList IncludedCharacters { get; set; } = new List(); + public IList IncludedInventoryFilters { get; set; } = new List(); public sealed class ServerConfiguration { diff --git a/Influx/Influx.csproj b/Influx/Influx.csproj index d142850..077c9f7 100644 --- a/Influx/Influx.csproj +++ b/Influx/Influx.csproj @@ -1,8 +1,8 @@ - net7.0-windows - 0.11 - 11.0 + net8.0-windows + 0.12 + 12 enable true false @@ -25,7 +25,7 @@ - + diff --git a/Influx/Influx/InfluxStatisticsClient.cs b/Influx/Influx/InfluxStatisticsClient.cs index 5f9f7e3..8d33fd6 100644 --- a/Influx/Influx/InfluxStatisticsClient.cs +++ b/Influx/Influx/InfluxStatisticsClient.cs @@ -1,5 +1,7 @@ using System; using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Globalization; using System.Linq; using System.Threading.Tasks; using Dalamud.Plugin.Services; @@ -23,7 +25,7 @@ internal sealed class InfluxStatisticsClient : IDisposable private readonly IReadOnlyDictionary _classJobToArrayIndex; private readonly IReadOnlyDictionary _classJobNames; private readonly IReadOnlyDictionary _expToJobs; - private readonly IReadOnlyDictionary _prices; + private readonly ReadOnlyDictionary _prices; public InfluxStatisticsClient(IChatGui chatGui, Configuration configuration, IDataManager dataManager, IClientState clientState, IPluginLog pluginLog) @@ -43,12 +45,14 @@ internal sealed class InfluxStatisticsClient : IDisposable .Where(x => x.Abbreviation.ToString() != "SMN") .ToDictionary(x => x.ExpArrayIndex, x => x.Abbreviation.ToString()); _prices = dataManager.GetExcelSheet()! + .AsEnumerable() .ToDictionary(x => x.RowId, x => new PriceInfo { Name = x.Name.ToString(), Normal = x.PriceLow, UiCategory = x.ItemUICategory.Row, - }); + }) + .AsReadOnly(); } public bool Enabled => _configuration.Server.Enabled && @@ -113,7 +117,7 @@ internal sealed class InfluxStatisticsClient : IDisposable foreach (var sub in subs) { values.Add(PointData.Measurement("submersibles") - .Tag("id", fc.CharacterId.ToString()) + .Tag("id", fc.CharacterId.ToString(CultureInfo.InvariantCulture)) .Tag("fc_name", fc.Name) .Tag("sub_id", $"{fc.CharacterId}_{sub.Id}") .Tag("sub_name", sub.Name) @@ -133,7 +137,8 @@ internal sealed class InfluxStatisticsClient : IDisposable var writeApi = client.GetWriteApiAsync(); await writeApi.WritePointsAsync( values, - _configuration.Server.Bucket, _configuration.Server.Organization); + _configuration.Server.Bucket, _configuration.Server.Organization) + .ConfigureAwait(false); _pluginLog.Verbose($"Influx: Sent {values.Count} data points to server"); } @@ -155,10 +160,10 @@ internal sealed class InfluxStatisticsClient : IDisposable x.LocalContentId == character.CharacterId && x.IncludeFreeCompany); Func pointData = s => PointData.Measurement(s) - .Tag("id", character.CharacterId.ToString()) + .Tag("id", character.CharacterId.ToString(CultureInfo.InvariantCulture)) .Tag("player_name", character.Name) .Tag("type", character.CharacterType.ToString()) - .Tag("fc_id", includeFc ? character.FreeCompanyId.ToString() : null) + .Tag("fc_id", includeFc ? character.FreeCompanyId.ToString(CultureInfo.InvariantCulture) : null) .Timestamp(date, WritePrecision.S); yield return pointData("currency") @@ -230,9 +235,9 @@ internal sealed class InfluxStatisticsClient : IDisposable var owner = update.Currencies.Keys.First(x => x.CharacterId == character.OwnerId); Func pointData = s => PointData.Measurement(s) - .Tag("id", character.CharacterId.ToString()) + .Tag("id", character.CharacterId.ToString(CultureInfo.InvariantCulture)) .Tag("player_name", owner.Name) - .Tag("player_id", character.OwnerId.ToString()) + .Tag("player_id", character.OwnerId.ToString(CultureInfo.InvariantCulture)) .Tag("type", character.CharacterType.ToString()) .Tag("retainer_name", character.Name) .Timestamp(date, WritePrecision.S); @@ -280,9 +285,9 @@ internal sealed class InfluxStatisticsClient : IDisposable yield return pointData("items") .Tag("filter_name", filterName) - .Tag("item_id", item.Key.ItemId.ToString()) + .Tag("item_id", item.Key.ItemId.ToString(CultureInfo.InvariantCulture)) .Tag("item_name", priceInfo.Name) - .Tag("hq", (item.Key.IsHq ? 1 : 0).ToString()) + .Tag("hq", (item.Key.IsHq ? 1 : 0).ToString(CultureInfo.InvariantCulture)) .Field("quantity", item.Sum(x => x.Quantity)) .Field("total_gil", item.Sum(x => x.Quantity) * (priceHq ? priceInfo.Hq : priceInfo.Normal)); } @@ -295,7 +300,7 @@ internal sealed class InfluxStatisticsClient : IDisposable update.FcStats.TryGetValue(character.CharacterId, out FcStats? fcStats); Func pointData = s => PointData.Measurement(s) - .Tag("id", character.CharacterId.ToString()) + .Tag("id", character.CharacterId.ToString(CultureInfo.InvariantCulture)) .Tag("fc_name", character.Name) .Tag("type", character.CharacterType.ToString()) .Timestamp(date, WritePrecision.S); diff --git a/Influx/InfluxPlugin.cs b/Influx/InfluxPlugin.cs index 4821a4c..e0b759c 100644 --- a/Influx/InfluxPlugin.cs +++ b/Influx/InfluxPlugin.cs @@ -18,7 +18,8 @@ using LLib; namespace Influx; [SuppressMessage("ReSharper", "UnusedType.Global")] -public sealed class InfluxPlugin : IDalamudPlugin +[SuppressMessage("Performance", "CA1812")] +internal sealed class InfluxPlugin : IDalamudPlugin { private readonly object _lock = new(); private readonly DalamudPluginInterface _pluginInterface; diff --git a/Influx/LocalStatistics/FcStatsCalculator.cs b/Influx/LocalStatistics/FcStatsCalculator.cs index 009fa19..9338577 100644 --- a/Influx/LocalStatistics/FcStatsCalculator.cs +++ b/Influx/LocalStatistics/FcStatsCalculator.cs @@ -16,7 +16,7 @@ using Newtonsoft.Json; namespace Influx.LocalStatistics; -public class FcStatsCalculator : IDisposable +internal sealed class FcStatsCalculator : IDisposable { private readonly DalamudPluginInterface _pluginInterface; private readonly IClientState _clientState; @@ -29,7 +29,7 @@ public class FcStatsCalculator : IDisposable private readonly Dictionary _cache = new(); - private Status? _status = null; + private Status? _status; public FcStatsCalculator( IDalamudPlugin plugin, diff --git a/Influx/LocalStatistics/LocalStats.cs b/Influx/LocalStatistics/LocalStats.cs index f8d810f..410cf84 100644 --- a/Influx/LocalStatistics/LocalStats.cs +++ b/Influx/LocalStatistics/LocalStats.cs @@ -9,7 +9,7 @@ public sealed record LocalStats public byte GcRank { get; init; } public bool SquadronUnlocked { get; init; } public byte MaxLevel { get; init; } = 90; - public List ClassJobLevels { get; set; } = new(); + public IList ClassJobLevels { get; init; } = new List(); public byte StartingTown { get; init; } public int MsqCount { get; set; } = -1; public string? MsqName { get; set; } diff --git a/Influx/LocalStatistics/LocalStatsCalculator.cs b/Influx/LocalStatistics/LocalStatsCalculator.cs index 6becad3..e55f717 100644 --- a/Influx/LocalStatistics/LocalStatsCalculator.cs +++ b/Influx/LocalStatistics/LocalStatsCalculator.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Collections.ObjectModel; using System.IO; using System.Linq; using System.Threading.Tasks; @@ -111,7 +112,7 @@ internal sealed class LocalStatsCalculator : IDisposable UpdateStatistics(); } - private IReadOnlyList PopulateStartingCities(List quests, uint envoyQuestId, + private static ReadOnlyCollection PopulateStartingCities(List quests, uint envoyQuestId, uint startingQuestId, bool popCallOfTheSea) { QuestInfo callOfTheSea = quests.First(x => x.PreviousQuestIds.Contains(envoyQuestId)); @@ -119,12 +120,10 @@ internal sealed class LocalStatsCalculator : IDisposable quests.Remove(callOfTheSea); List startingCityQuests = new List { callOfTheSea }; - uint? questId = envoyQuestId; - QuestInfo? quest; - + uint questId = envoyQuestId; do { - quest = quests.First(x => x.RowId == questId); + QuestInfo quest = quests.First(x => x.RowId == questId); quests.Remove(quest); if (quest.Name == "Close to Home") @@ -133,14 +132,14 @@ internal sealed class LocalStatsCalculator : IDisposable { RowId = startingQuestId, Name = "Coming to ...", - PreviousQuestIds = new(), + PreviousQuestIds = new List(), Genre = quest.Genre, }; } startingCityQuests.Add(quest); questId = quest.PreviousQuestIds.FirstOrDefault(); - } while (questId != null && questId != 0); + } while (questId != 0); return Enumerable.Reverse(startingCityQuests).ToList().AsReadOnly(); } diff --git a/Influx/LocalStatistics/QuestInfo.cs b/Influx/LocalStatistics/QuestInfo.cs index f2ace6f..1b33ebe 100644 --- a/Influx/LocalStatistics/QuestInfo.cs +++ b/Influx/LocalStatistics/QuestInfo.cs @@ -6,6 +6,6 @@ public sealed class QuestInfo { public required uint RowId { get; init; } public required string Name { get; init; } - public required List PreviousQuestIds { get; init; } + public required IList PreviousQuestIds { get; init; } public required uint Genre { get; init; } } diff --git a/Influx/SubmarineTracker/Build.cs b/Influx/SubmarineTracker/Build.cs index b568247..7045e12 100644 --- a/Influx/SubmarineTracker/Build.cs +++ b/Influx/SubmarineTracker/Build.cs @@ -2,21 +2,22 @@ namespace Influx.SubmarineTracker; -public class Build +internal sealed class Build { public Build(object @delegate) { - + ArgumentNullException.ThrowIfNull(@delegate); + Type type = @delegate.GetType(); HullIdentifier = - (string)@delegate.GetType().GetProperty("HullIdentifier")!.GetValue(@delegate)!; + (string)type.GetProperty("HullIdentifier")!.GetValue(@delegate)!; SternIdentifier = - (string)@delegate.GetType().GetProperty("SternIdentifier")!.GetValue(@delegate)!; + (string)type.GetProperty("SternIdentifier")!.GetValue(@delegate)!; BowIdentifier = - (string)@delegate.GetType().GetProperty("BowIdentifier")!.GetValue(@delegate)!; + (string)type.GetProperty("BowIdentifier")!.GetValue(@delegate)!; BridgeIdentifier = - (string)@delegate.GetType().GetProperty("BridgeIdentifier")!.GetValue(@delegate)!; + (string)type.GetProperty("BridgeIdentifier")!.GetValue(@delegate)!; FullIdentifier = - (string)@delegate.GetType().GetMethod("FullIdentifier")!.Invoke(@delegate, Array.Empty())!; + (string)type.GetMethod("FullIdentifier")!.Invoke(@delegate, Array.Empty())!; } public string HullIdentifier { get; } diff --git a/Influx/SubmarineTracker/FcSubmarines.cs b/Influx/SubmarineTracker/FcSubmarines.cs index 6159d57..848499f 100644 --- a/Influx/SubmarineTracker/FcSubmarines.cs +++ b/Influx/SubmarineTracker/FcSubmarines.cs @@ -1,13 +1,15 @@ -using System.Collections; +using System; +using System.Collections; using System.Collections.Generic; using System.Linq; namespace Influx.SubmarineTracker; -public sealed class FcSubmarines +internal sealed class FcSubmarines { public FcSubmarines(object @delegate) { + ArgumentNullException.ThrowIfNull(@delegate); Submarines = ((IEnumerable)@delegate.GetType().GetField("Submarines")!.GetValue(@delegate)!) .Cast() .Select(x => new Submarine(x)) diff --git a/Influx/SubmarineTracker/Submarine.cs b/Influx/SubmarineTracker/Submarine.cs index ac27ce4..40c2996 100644 --- a/Influx/SubmarineTracker/Submarine.cs +++ b/Influx/SubmarineTracker/Submarine.cs @@ -2,21 +2,23 @@ namespace Influx.SubmarineTracker; -public sealed class Submarine +internal sealed class Submarine { public Submarine(object @delegate) { - Name = (string)@delegate.GetType().GetProperty("Name")!.GetValue(@delegate)!; - Level = (ushort)@delegate.GetType().GetProperty("Rank")!.GetValue(@delegate)!; - Build = new Build(@delegate.GetType().GetProperty("Build")!.GetValue(@delegate)!); + ArgumentNullException.ThrowIfNull(@delegate); + Type type = @delegate.GetType(); + Name = (string)type.GetProperty("Name")!.GetValue(@delegate)!; + Level = (ushort)type.GetProperty("Rank")!.GetValue(@delegate)!; + Build = new Build(type.GetProperty("Build")!.GetValue(@delegate)!); try { - (uint predictedLevel, double _) = ((uint, double))@delegate.GetType().GetMethod("PredictExpGrowth")!.Invoke(@delegate, Array.Empty())!; + (uint predictedLevel, double _) = ((uint, double))type.GetMethod("PredictExpGrowth")!.Invoke(@delegate, Array.Empty())!; PredictedLevel = (ushort)predictedLevel; - bool onVoyage = (bool)@delegate.GetType().GetMethod("IsOnVoyage")!.Invoke(@delegate, Array.Empty())!; - bool returned = (bool)@delegate.GetType().GetMethod("IsDone")!.Invoke(@delegate, Array.Empty())!; + bool onVoyage = (bool)type.GetMethod("IsOnVoyage")!.Invoke(@delegate, Array.Empty())!; + bool returned = (bool)type.GetMethod("IsDone")!.Invoke(@delegate, Array.Empty())!; if (onVoyage) State = returned ? EState.Returned : EState.Voyage; else diff --git a/Influx/SubmarineTracker/SubmarineStats.cs b/Influx/SubmarineTracker/SubmarineStats.cs index 00926ef..e7d283c 100644 --- a/Influx/SubmarineTracker/SubmarineStats.cs +++ b/Influx/SubmarineTracker/SubmarineStats.cs @@ -1,6 +1,6 @@ namespace Influx.SubmarineTracker; -public sealed class SubmarineStats +internal sealed class SubmarineStats { public required string Name { get; init; } public required int Id { get; init; } diff --git a/Influx/SubmarineTracker/SubmarineTrackerIpc.cs b/Influx/SubmarineTracker/SubmarineTrackerIpc.cs index 6c40781..832fb8c 100644 --- a/Influx/SubmarineTracker/SubmarineTrackerIpc.cs +++ b/Influx/SubmarineTracker/SubmarineTrackerIpc.cs @@ -1,6 +1,8 @@ using System.Collections; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Linq; +using Dalamud.Plugin; using Influx.AllaganTools; using LLib; @@ -15,9 +17,10 @@ internal sealed class SubmarineTrackerIpc _dalamudReflector = dalamudReflector; } + [SuppressMessage("Reliability", "CA2000:Dispose objects before losing scope")] public Dictionary> GetSubmarineStats(List characters) { - if (_dalamudReflector.TryGetDalamudPlugin("Submarine Tracker", out var it, false, true)) + if (_dalamudReflector.TryGetDalamudPlugin("Submarine Tracker", out IDalamudPlugin? it, false, true)) { var submarineData = it.GetType().Assembly.GetType("SubmarineTracker.Data.Submarines"); var knownSubmarineData = submarineData!.GetField("KnownSubmarines")!; diff --git a/Influx/Windows/ConfigurationWindow.cs b/Influx/Windows/ConfigurationWindow.cs index 618a02e..fd5b7ca 100644 --- a/Influx/Windows/ConfigurationWindow.cs +++ b/Influx/Windows/ConfigurationWindow.cs @@ -19,7 +19,7 @@ internal sealed class ConfigurationWindow : Window private readonly Configuration _configuration; private readonly AllaganToolsIpc _allaganToolsIpc; private string[] _filterNames = Array.Empty(); - private int _filterIndexToAdd = 0; + private int _filterIndexToAdd; public ConfigurationWindow(DalamudPluginInterface pluginInterface, IClientState clientState, Configuration configuration, AllaganToolsIpc allaganToolsIpc) @@ -44,7 +44,9 @@ internal sealed class ConfigurationWindow : Window } } - public override void OnOpen() + public override void OnOpen() => RefreshFilters(); + + private void RefreshFilters() { _filterNames = _allaganToolsIpc.GetSearchFilters() .Select(x => x.Value) @@ -125,8 +127,9 @@ internal sealed class ConfigurationWindow : Window if (ImGui.Button("Remove inclusion")) { - _configuration.IncludedCharacters.RemoveAll( - c => c.LocalContentId == _clientState.LocalContentId); + var characterInfo = + _configuration.IncludedCharacters.First(c => c.LocalContentId == _clientState.LocalContentId); + _configuration.IncludedCharacters.Remove(characterInfo); Save(); } } @@ -221,7 +224,8 @@ internal sealed class ConfigurationWindow : Window { ImGui.Combo("Add Search Filter", ref _filterIndexToAdd, _filterNames, _filterNames.Length); - ImGui.BeginDisabled(_configuration.IncludedInventoryFilters.Any(x => x.Name == _filterNames[_filterIndexToAdd])); + ImGui.BeginDisabled( + _configuration.IncludedInventoryFilters.Any(x => x.Name == _filterNames[_filterIndexToAdd])); if (ImGuiComponents.IconButtonWithText(FontAwesomeIcon.Plus, "Track Filter")) { _configuration.IncludedInventoryFilters.Add(new Configuration.FilterInfo @@ -238,6 +242,11 @@ internal sealed class ConfigurationWindow : Window ImGui.TextColored(ImGuiColors.DalamudRed, "You don't have any search filters, or the AllaganTools integration doesn't work."); } + + ImGui.Separator(); + + if (ImGuiComponents.IconButtonWithText(FontAwesomeIcon.Sync, "Refresh Filters")) + RefreshFilters(); } private void Save(bool sendEvent = false) diff --git a/Influx/Windows/StatisticsWindow.cs b/Influx/Windows/StatisticsWindow.cs index a20f6c4..2c3cca3 100644 --- a/Influx/Windows/StatisticsWindow.cs +++ b/Influx/Windows/StatisticsWindow.cs @@ -1,4 +1,5 @@ using System.Collections.Generic; +using System.Globalization; using System.Linq; using System.Numerics; using Dalamud.Interface.Windowing; @@ -36,7 +37,7 @@ internal sealed class StatisticsWindow : Window ImGui.Text(row.Name); if (ImGui.TableNextColumn()) - ImGui.Text(row.Gil.ToString("N0")); + ImGui.Text(row.Gil.ToString("N0", CultureInfo.InvariantCulture)); } ImGui.EndTable(); diff --git a/Influx/packages.lock.json b/Influx/packages.lock.json index 9cf869b..0fa8f85 100644 --- a/Influx/packages.lock.json +++ b/Influx/packages.lock.json @@ -1,7 +1,7 @@ { "version": 1, "dependencies": { - "net7.0-windows7.0": { + "net8.0-windows7.0": { "DalamudPackager": { "type": "Direct", "requested": "[2.1.12, )", @@ -25,9 +25,9 @@ }, "Microsoft.Extensions.ObjectPool": { "type": "Direct", - "requested": "[8.0.2, )", - "resolved": "8.0.2", - "contentHash": "LA7lDy048CVjGCwsPqRFVwH8vl5ooHmSFji13Oczw+mOnGhqenWXttkWcJ5dhIR0bhayZrQz4BaSPEVtE8Tt0A==" + "requested": "[8.0.3, )", + "resolved": "8.0.3", + "contentHash": "sk/TGiccSeXUtVeBfFlWJnzp6xLlAxIW+bCHs7uVPLFPQk8vICNmu9Gc3JsKOn6fQuRkrPetQ8EHv4dCiMqhxg==" }, "CsvHelper": { "type": "Transitive", @@ -195,7 +195,7 @@ "autoretainerapi": { "type": "Project", "dependencies": { - "ECommons": "[2.1.0, )" + "ECommons": "[2.1.0.7, )" } }, "ecommons": { diff --git a/LLib b/LLib index 2f6ef35..3792244 160000 --- a/LLib +++ b/LLib @@ -1 +1 @@ -Subproject commit 2f6ef354c401a9f1bb9b807327acad7e98662a2e +Subproject commit 3792244261a9f5426a7916f5a6dd1966238ba84a diff --git a/global.json b/global.json new file mode 100644 index 0000000..b5b37b6 --- /dev/null +++ b/global.json @@ -0,0 +1,7 @@ +{ + "sdk": { + "version": "8.0.0", + "rollForward": "latestMajor", + "allowPrerelease": false + } +} \ No newline at end of file