diff --git a/.editorconfig b/.editorconfig index 9416600c2..e0ad66f44 100644 --- a/.editorconfig +++ b/.editorconfig @@ -1,14 +1,1078 @@ -root = true +# Remove the line below if you want to inherit .editorconfig settings from higher directories +root = true -[*] -end_of_line = crlf -insert_final_newline = true -trim_trailing_whitespace = true - -# 4 space indentation +# C# files [*.cs] -indent_style = space + +#### Core EditorConfig Options #### + +# Indentation and spacing indent_size = 4 +indent_style = space +tab_width = 4 + +# New line preferences +end_of_line = crlf +insert_final_newline = false + +#### .NET Coding Conventions #### + +# Organize usings +dotnet_separate_import_directive_groups = false +dotnet_sort_system_directives_first = false +file_header_template = unset + +# this. and Me. preferences +dotnet_style_qualification_for_event = false +dotnet_style_qualification_for_field = false +dotnet_style_qualification_for_method = false +dotnet_style_qualification_for_property = false + +# Language keywords vs BCL types preferences +dotnet_style_predefined_type_for_locals_parameters_members = true +dotnet_style_predefined_type_for_member_access = true + +# Parentheses preferences +dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity +dotnet_style_parentheses_in_other_binary_operators = always_for_clarity +dotnet_style_parentheses_in_other_operators = never_if_unnecessary +dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity + +# Modifier preferences +dotnet_style_require_accessibility_modifiers = for_non_interface_members + +# Expression-level preferences +dotnet_style_coalesce_expression = true +dotnet_style_collection_initializer = true +dotnet_style_explicit_tuple_names = true +dotnet_style_namespace_match_folder = true +dotnet_style_null_propagation = true +dotnet_style_object_initializer = true +dotnet_style_operator_placement_when_wrapping = beginning_of_line +dotnet_style_prefer_auto_properties = true +dotnet_style_prefer_compound_assignment = true +dotnet_style_prefer_conditional_expression_over_assignment = true +dotnet_style_prefer_conditional_expression_over_return = true +dotnet_style_prefer_inferred_anonymous_type_member_names = true +dotnet_style_prefer_inferred_tuple_names = true +dotnet_style_prefer_is_null_check_over_reference_equality_method = true +dotnet_style_prefer_simplified_boolean_expressions = true +dotnet_style_prefer_simplified_interpolation = true + +# Field preferences +dotnet_style_readonly_field = true + +# Parameter preferences +dotnet_code_quality_unused_parameters = all + +# Suppression preferences +dotnet_remove_unnecessary_suppression_exclusions = 0 + +# New line preferences +dotnet_style_allow_multiple_blank_lines_experimental = true +dotnet_style_allow_statement_immediately_after_block_experimental = true + +#### C# Coding Conventions #### + +# var preferences +csharp_style_var_elsewhere = true +csharp_style_var_for_built_in_types = true +csharp_style_var_when_type_is_apparent = true + +# Expression-bodied members +csharp_style_expression_bodied_accessors = true:suggestion +csharp_style_expression_bodied_constructors = false:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = false:silent +csharp_style_expression_bodied_methods = false:silent +csharp_style_expression_bodied_operators = false:silent +csharp_style_expression_bodied_properties = true:silent + +# Pattern matching preferences +csharp_style_pattern_matching_over_as_with_null_check = true +csharp_style_pattern_matching_over_is_with_cast_check = true +csharp_style_prefer_extended_property_pattern = true +csharp_style_prefer_not_pattern = true +csharp_style_prefer_pattern_matching = true +csharp_style_prefer_switch_expression = true + +# Null-checking preferences +csharp_style_conditional_delegate_call = true + +# Modifier preferences +csharp_prefer_static_local_function = true:suggestion +csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async + +# Code-block preferences +csharp_prefer_braces = true:warning +csharp_prefer_simple_using_statement = true:suggestion +csharp_style_namespace_declarations = block_scoped:silent + +# Expression-level preferences +csharp_prefer_simple_default_expression = true:suggestion +csharp_style_deconstructed_variable_declaration = true:suggestion +csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_prefer_index_operator = true:suggestion +csharp_style_prefer_local_over_anonymous_function = true:suggestion +csharp_style_prefer_null_check_over_type_check = true:suggestion +csharp_style_prefer_range_operator = true:suggestion +csharp_style_prefer_tuple_swap = true:suggestion +csharp_style_throw_expression = true:suggestion +csharp_style_unused_value_assignment_preference = discard_variable:suggestion +csharp_style_unused_value_expression_statement_preference = discard_variable:silent + +# 'using' directive preferences +csharp_using_directive_placement = outside_namespace:silent + +# New line preferences +csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true +csharp_style_allow_blank_lines_between_consecutive_braces_experimental = true +csharp_style_allow_embedded_statements_on_same_line_experimental = true:silent + +#### C# Formatting Rules #### + +# New line preferences +csharp_new_line_before_catch = true +csharp_new_line_before_else = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_anonymous_types = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_open_brace = all +csharp_new_line_between_query_expression_clauses = true + +# Indentation preferences +csharp_indent_block_contents = true +csharp_indent_braces = false +csharp_indent_case_contents = true +csharp_indent_case_contents_when_block = true +csharp_indent_labels = one_less_than_current +csharp_indent_switch_labels = true + +# Space preferences +csharp_space_after_cast = false +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_after_comma = true +csharp_space_after_dot = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_after_semicolon_in_for_statement = true +csharp_space_around_binary_operators = before_and_after +csharp_space_around_declaration_statements = false +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_before_comma = false +csharp_space_before_dot = false +csharp_space_before_open_square_brackets = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_between_square_brackets = false + +# Wrapping preferences +csharp_preserve_single_line_blocks = true +csharp_preserve_single_line_statements = true + +#### 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.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.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_analyzer_diagnostic.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 + +# CA2362: Unsafe DataSet or DataTable in auto-generated serializable type can be vulnerable to remote code execution attacks +dotnet_diagnostic.CA2362.severity = warning + +# CA2356: Unsafe DataSet or DataTable type in web deserializable object graph +dotnet_diagnostic.CA2356.severity = warning + +# CA1001: Types that own disposable fields should be disposable +dotnet_diagnostic.CA1001.severity = silent + +# CA1032: Implement standard exception constructors +dotnet_diagnostic.CA1032.severity = warning + +# CA1200: Avoid using cref tags with a prefix +dotnet_diagnostic.CA1200.severity = silent + +# CA1309: Use ordinal string comparison +dotnet_diagnostic.CA1309.severity = silent + +# CA1507: Use nameof to express symbol names +dotnet_diagnostic.CA1507.severity = suggestion + +# CA1802: Use literals where appropriate +dotnet_diagnostic.CA1802.severity = warning + +# CA1805: Do not initialize unnecessarily +dotnet_diagnostic.CA1805.severity = silent + +# CA1812: Avoid uninstantiated internal classes +dotnet_diagnostic.CA1812.severity = warning + +# CA1824: Mark assemblies with NeutralResourcesLanguageAttribute +dotnet_diagnostic.CA1824.severity = suggestion + +# CA1825: Avoid zero-length array allocations +dotnet_diagnostic.CA1825.severity = suggestion + +# CA1841: Prefer Dictionary.Contains methods +dotnet_diagnostic.CA1841.severity = suggestion + +# CA1845: Use span-based 'string.Concat' +dotnet_diagnostic.CA1845.severity = suggestion + +# CA2014: Do not use stackalloc in loops +dotnet_diagnostic.CA2014.severity = warning + +# CA2016: Forward the 'CancellationToken' parameter to methods +dotnet_diagnostic.CA2016.severity = suggestion + +# CA2234: Pass system uri objects instead of strings +dotnet_diagnostic.CA2234.severity = warning + +# CA2252: This API requires opting into preview features +dotnet_diagnostic.CA2252.severity = error + +# CA1000: Do not declare static members on generic types +dotnet_diagnostic.CA1000.severity = silent + +# 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 = silent + +# 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 = suggestion + +# CA1017: Mark assemblies with ComVisible +dotnet_diagnostic.CA1017.severity = warning + +# CA1018: Mark attributes with AttributeUsageAttribute +dotnet_diagnostic.CA1018.severity = suggestion + +# CA1019: Define accessors for attribute arguments +dotnet_diagnostic.CA1019.severity = warning + +# CA1021: Avoid out parameters +dotnet_diagnostic.CA1021.severity = warning + +# 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 = 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 = silent + +# CA1040: Avoid empty interfaces +dotnet_diagnostic.CA1040.severity = warning + +# CA1041: Provide ObsoleteAttribute message +dotnet_diagnostic.CA1041.severity = suggestion + +# 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 + +# CA1050: Declare types in namespaces +dotnet_diagnostic.CA1050.severity = suggestion + +# CA1051: Do not declare visible instance fields +dotnet_diagnostic.CA1051.severity = silent + +# 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 = suggestion + +# 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 = suggestion + +# CA1068: CancellationToken parameters must come last +dotnet_diagnostic.CA1068.severity = suggestion + +# CA1069: Enums values should not be duplicated +dotnet_diagnostic.CA1069.severity = suggestion + +# CA1070: Do not declare event fields as virtual +dotnet_diagnostic.CA1070.severity = suggestion + +# CA1303: Do not pass literals as localized parameters +dotnet_diagnostic.CA1303.severity = warning + +# CA1304: Specify CultureInfo +dotnet_diagnostic.CA1304.severity = silent + +# CA1305: Specify IFormatProvider +dotnet_diagnostic.CA1305.severity = silent + +# CA1307: Specify StringComparison for clarity +dotnet_diagnostic.CA1307.severity = warning + +# CA1308: Normalize strings to uppercase +dotnet_diagnostic.CA1308.severity = warning + +# CA1310: Specify StringComparison for correctness +dotnet_diagnostic.CA1310.severity = silent + +# CA1401: P/Invokes should not be visible +dotnet_diagnostic.CA1401.severity = suggestion + +# 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 = suggestion + +# CA1501: Avoid excessive inheritance +dotnet_diagnostic.CA1501.severity = warning + +# CA1502: Avoid excessive complexity +dotnet_diagnostic.CA1502.severity = warning + +# CA1505: Avoid unmaintainable code +dotnet_diagnostic.CA1505.severity = warning + +# CA1506: Avoid excessive class coupling +dotnet_diagnostic.CA1506.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 + +# CA1700: Do not name enum values 'Reserved' +dotnet_diagnostic.CA1700.severity = warning + +# CA1707: Identifiers should not contain underscores +dotnet_diagnostic.CA1707.severity = silent + +# CA1708: Identifiers should differ by more than case +dotnet_diagnostic.CA1708.severity = silent + +# CA1710: Identifiers should have correct suffix +dotnet_diagnostic.CA1710.severity = silent + +# CA1711: Identifiers should not have incorrect suffix +dotnet_diagnostic.CA1711.severity = silent + +# CA1712: Do not prefix enum values with type name +dotnet_diagnostic.CA1712.severity = silent + +# CA1713: Events should not have 'Before' or 'After' prefix +dotnet_diagnostic.CA1713.severity = warning + +# CA1715: Identifiers should have correct prefix +dotnet_diagnostic.CA1715.severity = silent + +# CA1716: Identifiers should not match keywords +dotnet_diagnostic.CA1716.severity = silent + +# CA1720: Identifier contains type name +dotnet_diagnostic.CA1720.severity = silent + +# 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 = silent + +# CA1727: Use PascalCase for named placeholders +dotnet_diagnostic.CA1727.severity = silent + +# CA1806: Do not ignore method results +dotnet_diagnostic.CA1806.severity = suggestion + +# CA1810: Initialize reference type static fields inline +dotnet_diagnostic.CA1810.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 = suggestion + +# CA1819: Properties should not return arrays +dotnet_diagnostic.CA1819.severity = warning # CA1820: Test for empty strings using string length dotnet_diagnostic.CA1820.severity = error + +# CA1821: Remove empty Finalizers +dotnet_diagnostic.CA1821.severity = suggestion + +# CA1822: Mark members as static +dotnet_diagnostic.CA1822.severity = suggestion + +# CA1823: Avoid unused private fields +dotnet_diagnostic.CA1823.severity = warning + +# CA1826: Do not use Enumerable methods on indexable collections +dotnet_diagnostic.CA1826.severity = suggestion + +# CA1827: Do not use Count() or LongCount() when Any() can be used +dotnet_diagnostic.CA1827.severity = suggestion + +# CA1828: Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used +dotnet_diagnostic.CA1828.severity = suggestion + +# CA1829: Use Length/Count property instead of Count() when available +dotnet_diagnostic.CA1829.severity = suggestion + +# CA1830: Prefer strongly-typed Append and Insert method overloads on StringBuilder +dotnet_diagnostic.CA1830.severity = suggestion + +# 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 = suggestion + +# CA1833: Use AsSpan or AsMemory instead of Range-based indexers when appropriate +dotnet_diagnostic.CA1833.severity = suggestion + +# CA1834: Consider using 'StringBuilder.Append(char)' when applicable +dotnet_diagnostic.CA1834.severity = suggestion + +# CA1835: Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync' +dotnet_diagnostic.CA1835.severity = suggestion + +# CA1836: Prefer IsEmpty over Count +dotnet_diagnostic.CA1836.severity = suggestion + +# CA1837: Use 'Environment.ProcessId' +dotnet_diagnostic.CA1837.severity = suggestion + +# CA1838: Avoid 'StringBuilder' parameters for P/Invokes +dotnet_diagnostic.CA1838.severity = silent + +# CA1839: Use 'Environment.ProcessPath' +dotnet_diagnostic.CA1839.severity = suggestion + +# CA1840: Use 'Environment.CurrentManagedThreadId' +dotnet_diagnostic.CA1840.severity = suggestion + +# CA1842: Do not use 'WhenAll' with a single task +dotnet_diagnostic.CA1842.severity = suggestion + +# CA1843: Do not use 'WaitAll' with a single task +dotnet_diagnostic.CA1843.severity = suggestion + +# CA1844: Provide memory-based overrides of async methods when subclassing 'Stream' +dotnet_diagnostic.CA1844.severity = suggestion + +# CA1846: Prefer 'AsSpan' over 'Substring' +dotnet_diagnostic.CA1846.severity = suggestion + +# CA1847: Use char literal for a single character lookup +dotnet_diagnostic.CA1847.severity = suggestion + +# CA1848: Use the LoggerMessage delegates +dotnet_diagnostic.CA1848.severity = silent + +# CA1849: Call async methods when in an async method +dotnet_diagnostic.CA1849.severity = warning + +# CA2000: Dispose objects before losing scope +dotnet_diagnostic.CA2000.severity = error + +# 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 = suggestion + +# CA2011: Avoid infinite recursion +dotnet_diagnostic.CA2011.severity = suggestion + +# CA2012: Use ValueTasks correctly +dotnet_diagnostic.CA2012.severity = suggestion + +# CA2013: Do not use ReferenceEquals with value types +dotnet_diagnostic.CA2013.severity = warning + +# CA2015: Do not define finalizers for types derived from MemoryManager +dotnet_diagnostic.CA2015.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 + +# CA2100: Review SQL queries for security vulnerabilities +dotnet_diagnostic.CA2100.severity = warning + +# CA2101: Specify marshaling for P/Invoke string arguments +dotnet_diagnostic.CA2101.severity = suggestion + +# CA2109: Review visible event handlers +dotnet_diagnostic.CA2109.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 = silent + +# CA2207: Initialize value type static fields inline +dotnet_diagnostic.CA2207.severity = warning + +# CA2208: Instantiate argument exceptions correctly +dotnet_diagnostic.CA2208.severity = suggestion + +# CA2211: Non-constant fields should not be visible +dotnet_diagnostic.CA2211.severity = suggestion + +# 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 = silent + +# CA2216: Disposable types should declare finalizer +dotnet_diagnostic.CA2216.severity = warning + +# CA2217: Do not mark enums with FlagsAttribute +dotnet_diagnostic.CA2217.severity = warning + +# CA2219: Do not raise exceptions in finally clauses +dotnet_diagnostic.CA2219.severity = suggestion + +# 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 + +# CA2229: Implement serialization constructors +dotnet_diagnostic.CA2229.severity = silent + +# CA2231: Overload operator equals on overriding value type Equals +dotnet_diagnostic.CA2231.severity = suggestion + +# 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 = suggestion + +# CA2242: Test for NaN correctly +dotnet_diagnostic.CA2242.severity = suggestion + +# CA2243: Attribute string literals should parse correctly +dotnet_diagnostic.CA2243.severity = warning + +# CA2244: Do not duplicate indexed element initializations +dotnet_diagnostic.CA2244.severity = suggestion + +# CA2245: Do not assign a property to itself +dotnet_diagnostic.CA2245.severity = suggestion + +# CA2246: Assigning symbol and its member in the same statement +dotnet_diagnostic.CA2246.severity = suggestion + +# 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 = suggestion + +# CA2249: Consider using 'string.Contains' instead of 'string.IndexOf' +dotnet_diagnostic.CA2249.severity = suggestion + +# CA2250: Use 'ThrowIfCancellationRequested' +dotnet_diagnostic.CA2250.severity = suggestion + +# CA2251: Use 'string.Equals' +dotnet_diagnostic.CA2251.severity = silent + +# CA2253: Named placeholders should not be numeric values +dotnet_diagnostic.CA2253.severity = suggestion + +# CA2254: Template should be a static expression +dotnet_diagnostic.CA2254.severity = suggestion + +# 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 + +# 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 + +# CA2361: Ensure auto-generated class containing DataSet.ReadXml() is not used with untrusted data +dotnet_diagnostic.CA2361.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 = silent + +# CA3075: Insecure DTD processing in XML +dotnet_diagnostic.CA3075.severity = silent + +# CA3076: Insecure XSLT script processing. +dotnet_diagnostic.CA3076.severity = silent + +# CA3077: Insecure Processing in API Design, XmlDocument and XmlTextReader +dotnet_diagnostic.CA3077.severity = silent + +# CA3147: Mark Verb Handlers With Validate Antiforgery Token +dotnet_diagnostic.CA3147.severity = silent + +# CA5350: Do Not Use Weak Cryptographic Algorithms +dotnet_diagnostic.CA5350.severity = silent + +# CA5351: Do Not Use Broken Cryptographic Algorithms +dotnet_diagnostic.CA5351.severity = silent + +# CA5358: Review cipher mode usage with cryptography experts +dotnet_diagnostic.CA5358.severity = warning + +# CA5359: Do Not Disable Certificate Validation +dotnet_diagnostic.CA5359.severity = silent + +# CA5360: Do Not Call Dangerous Methods In Deserialization +dotnet_diagnostic.CA5360.severity = silent + +# 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 = silent + +# CA5364: Do Not Use Deprecated Security Protocols +dotnet_diagnostic.CA5364.severity = silent + +# CA5365: Do Not Disable HTTP Header Checking +dotnet_diagnostic.CA5365.severity = silent + +# CA5366: Use XmlReader for 'DataSet.ReadXml()' +dotnet_diagnostic.CA5366.severity = silent + +# 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 = silent + +# CA5369: Use XmlReader for 'XmlSerializer.Deserialize()' +dotnet_diagnostic.CA5369.severity = silent + +# CA5370: Use XmlReader for XmlValidatingReader constructor +dotnet_diagnostic.CA5370.severity = silent + +# CA5371: Use XmlReader for 'XmlSchema.Read()' +dotnet_diagnostic.CA5371.severity = silent + +# CA5372: Use XmlReader for XPathDocument constructor +dotnet_diagnostic.CA5372.severity = silent + +# CA5373: Do not use obsolete key derivation function +dotnet_diagnostic.CA5373.severity = silent + +# CA5374: Do Not Use XslTransform +dotnet_diagnostic.CA5374.severity = silent + +# 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 = silent + +# 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 = silent + +# CA5385: Use RivestShamirAdleman (RSA) Algorithm With Sufficient Key Size +dotnet_diagnostic.CA5385.severity = silent + +# 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 = silent + +# 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 + +# IDE0048: Add parentheses for clarity +dotnet_diagnostic.IDE0048.severity = suggestion + +# IDE0011: Add braces +dotnet_diagnostic.IDE0011.severity = warning + +# IDE0058: Expression value is never used +dotnet_diagnostic.IDE0058.severity = silent + +# IDE0027: Use expression body for accessors +dotnet_diagnostic.IDE0027.severity = suggestion + +# S125: Sections of code should not be commented out +dotnet_diagnostic.S125.severity = silent +csharp_style_prefer_method_group_conversion = true:silent + +[*.{cs,vb}] +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_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion +dotnet_style_prefer_conditional_expression_over_return = true:suggestion +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 +dotnet_style_readonly_field = true:suggestion +dotnet_style_predefined_type_for_locals_parameters_members = true:silent +dotnet_style_predefined_type_for_member_access = true:silent +dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent +dotnet_style_allow_statement_immediately_after_block_experimental = true:silent +dotnet_style_allow_multiple_blank_lines_experimental = true:silent +dotnet_style_qualification_for_field = false:silent +dotnet_style_qualification_for_property = false:silent +dotnet_style_qualification_for_method = false:silent +dotnet_style_qualification_for_event = false:silent + +# IDE0046: Convert to conditional expression +dotnet_diagnostic.IDE0046.severity = suggestion + +# IDE0045: Convert to conditional expression +dotnet_diagnostic.IDE0045.severity = suggestion diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 000000000..b9e14ef73 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,19 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: weekly + rebase-strategy: auto + + - package-ecosystem: "nuget" # See documentation for possible values + directory: "/" # Location of package manifests + schedule: + interval: "daily" + ignore: + - dependency-name: "NUnit" + - dependency-name: "NUnit3TestAdapter" + - dependency-name: "SonarAnalyzer.CSharp" + - dependency-name: "morelinq" + - dependency-name: "Microsoft.NET.Test.Sdk" + diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml new file mode 100644 index 000000000..d035a1079 --- /dev/null +++ b/.github/workflows/dotnet.yml @@ -0,0 +1,87 @@ +name: .NET build and test +env: + CURRENT_VERSION: 0.96.${{ github.run_number }} + LAST_COMMIT_MESSAGE: ${{ github.event.head_commit.message }} + +on: + push: + pull_request: + +jobs: + build: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + steps: + - uses: actions/checkout@v4 + - name: Setup .NET + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 6.0.x + - name: Restore dependencies + run: dotnet restore + - name: Build + run: dotnet build --configuration Release --no-restore + - name: Test + run: dotnet test --no-build --verbosity normal --configuration Release + - name: Publish Unit Test Results + uses: actions/upload-artifact@v3 + if: failure() + with: + name: TestResult + path: "TestResult/**/*" + + deployRelease: + if: github.ref == 'refs/heads/release' + runs-on: windows-latest + needs: build + steps: + - uses: actions/checkout@v4 + - name: Setup .NET + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 6.0.x + - name: Restore dependencies + run: dotnet restore + - name: Build + run: dotnet build --configuration Release --no-restore + - name: NugetPush + env: + NUGET_TOKEN_EXISTS: ${{ secrets.NUGET_TOKEN }} + if: env.NUGET_TOKEN_EXISTS != '' + run: | + ls ./ClosedXML/bin/Release + dotnet nuget push .\ClosedXML\bin\Release\*.nupkg --skip-duplicate --api-key ${{secrets.NUGET_TOKEN}} --source https://api.nuget.org/v3/index.json + - name: GithubReleasesPush + uses: "marvinpinto/action-automatic-releases@latest" + with: + repo_token: "${{ secrets.GITHUB_TOKEN }}" + automatic_release_tag: ${{ env.CURRENT_VERSION }} + prerelease: false + title: "Release Build ${{ env.CURRENT_VERSION }}" + files: | + ./ClosedXML/bin/Release/*.nupkg + ./ClosedXML/bin/Release/*.snupkg + + deployTest: + if: github.ref == 'refs/heads/develop' + runs-on: windows-latest + needs: build + steps: + - uses: actions/checkout@v4 + - name: Setup .NET + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 6.0.x + - name: Restore dependencies + run: dotnet restore + - name: Build + run: dotnet build --configuration Release --no-restore + - name: NugetPush + env: + NUGET_TOKEN_EXISTS: ${{ secrets.NUGET_TEST_TOKEN }} + if: env.NUGET_TOKEN_EXISTS != '' + run: | + ls ./ClosedXML/bin/Release + dotnet nuget push .\ClosedXML\bin\Release\*.nupkg --skip-duplicate --api-key ${{secrets.NUGET_TEST_TOKEN}} --source https://apiint.nugettest.org/v3/index.json \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 000000000..f00e1dd40 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,5 @@ +{ + "recommendations": [ + "ms-dotnettools.csharp" + ] +} \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 000000000..0f5b1d3eb --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,27 @@ +{ + // Use IntelliSense to find out which attributes exist for C# debugging + // Use hover for the description of the existing attributes + // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md + "version": "0.2.0", + "configurations": [ + { + "name": ".NET Core Launch (console)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + // If you have changed target frameworks, make sure to update the program path. + "program": "${workspaceFolder}/OpenXmlToHtmlTests/bin/Debug/netcoreapp3.1/OpenXmlToHtmlTests.dll", + "args": [], + "cwd": "${workspaceFolder}/OpenXmlToHtmlTests", + // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": ".NET Core Attach", + "type": "coreclr", + "request": "attach", + "processId": "${command:pickProcess}" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..23fd35f0e --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "editor.formatOnSave": true +} \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 000000000..64ffa4e96 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,15 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "update nuget", + "command": "${workspaceFolder}/.vscode/updateNuget.sh", + "args": [], + "group": "build", + "presentation": { + "reveal": "always" + }, + "problemMatcher": "$msCompile" + } + ] +} \ No newline at end of file diff --git a/.vscode/updateNuget.sh b/.vscode/updateNuget.sh new file mode 100755 index 000000000..691c854ea --- /dev/null +++ b/.vscode/updateNuget.sh @@ -0,0 +1,13 @@ +#!/bin/bash +regex='PackageReference Include="([^"]*)" Version="([^"]*)"' +find . -name "*.*proj" | while read proj; do + while read line; do + if [[ $line =~ $regex ]]; then + name="${BASH_REMATCH[1]}" + version="${BASH_REMATCH[2]}" + if [[ $version != *-* ]]; then + dotnet add "$proj" package "$name" + fi + fi + done <"$proj" +done diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 477b942db..dc7b628ab 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,9 +1,10 @@ # Developer guidelines + The [OpenXML specification](https://www.ecma-international.org/publications/standards/Ecma-376.htm) is a large and complicated beast. In order for ClosedXML, the wrapper around OpenXML, to support all the features, we rely on community contributions. Before opening an issue to request a new feature, we'd like to urge you to try to implement it yourself and log a pull request. Here are some tips. -* Before starting a large pull request, log an issue and outline the problem and a broad outline of your solution. The maintainers will discuss the issue with you and possibly propose some alternative approaches to align with the ClosedXML development conventions. +* Before starting a large pull request, log an issue and outline the problem and a broad outline of your solution. The maintainers will discuss the issue with you and possibly propose some alternative approaches to align with the ClosedXML development conventions. * Please submit pull requests that are based on the `develop` branch. * Where possible, pull requests should include unit tests that cover as many uses cases as possible. * We recommend Visual Studio 2019 or higher as the development environment. If you do use Visual Studio, please install these extensions: @@ -11,10 +12,9 @@ Here are some tips. * If you use a version of Visual Studio lower than 2017, you should install [editorconfig]() support. Read more about [EditorConfig](http://www.editorconfig.org). * We use 4 spaces for code indentation. This is the default in Visual Studio. Don't leave any trailing white space at the end of lines or files. - - ## Working with Excel file internals -Excel files (`.xlsx` and `.xlsm`) are zip packages. You can easily verify this by renaming the extension any Excel file to `.zip` and opening the file in your favourite `.zip` file editor. + +Excel files (`.xlsx` and `.xlsm`) are zip packages. You can easily verify this by renaming the extension any Excel file to `.zip` and opening the file in your favorite `.zip` file editor. Internally, the file contains files (also known as parts) that represent different entities in the Excel framework, for example `workbook.xml` and `table1.xml`. The [OpenXML specification](https://www.ecma-international.org/publications/standards/Ecma-376.htm) documents all these parts and their contents. @@ -24,24 +24,53 @@ Making changes to the ClosedXML code may change the input or output of the packa A ClosedXML developer will often want to compare the internals of 2 similar Excel files. For example if you want to compare the output of a specific package part before and after your code changes. The long, difficult way would be to extract the package parts of the 2 files and manually compare the relevant parts. To ease this, we recommend this tooling stack: -- [Total Commander](https://www.ghisler.com/download.htm) -- [WinMerge](http://winmerge.org/downloads) version `2.14.0`, because subsequent versions for [some reason](https://bitbucket.org/winmerge/winmerge/issues/152/displayxmlfiles-plugin-not-included-with) excludes the required `DisplayXMLFiles.dll` plugin. -- Set Total Commander [to use WinMerge](https://superuser.com/questions/238039/can-i-replace-internal-diff-in-total-commander-with-a-custom-tool) as its compare tool. -- In WinMerge, enable `Plugins > Automatic Prediffer` +* [Total Commander](https://www.ghisler.com/download.htm) +* [WinMerge](http://winmerge.org/downloads) version `2.14.0`, because subsequent versions for [some reason](https://bitbucket.org/winmerge/winmerge/issues/152/displayxmlfiles-plugin-not-included-with) excludes the required `DisplayXMLFiles.dll` plugin. +* Set Total Commander [to use WinMerge](https://superuser.com/questions/238039/can-i-replace-internal-diff-in-total-commander-with-a-custom-tool) as its compare tool. +* In WinMerge, enable `Plugins > Automatic Prediffer` Now, to compare 2 similar, but not exact Excel files: -- In Total Commander, navigate to the 1st file in the left-hand pane and the 2nd file in the right-hand pane. -- Press `Ctrl+PageDown` to "enter" the package. You should see, among others, a `[Content_Types].xml` file in both panes. -- You can now compare all package parts by selecting `Commands > Synchronise Dirs...`. Press `Compare`. This will do a full, recursive comparison. You can filter out parts that are identical. -- You can select an item that differs and press `Ctrl+F3` to open the two parts in WinMerge and see the exact comparison of the part's contents. The XML files should automatically reformat/reindent to ease the comparison instead of showing the entire XML contents on a single line. This is the reason for requiring the `DisplayXMLFiles.dll` plugin. -- In Total Commander, you can also navigate to specific files in the left-hand and right-hand panes and select `File > Compare by Content...`. This will open WinMerge directly. -- Note that since WinMerge reformats the XML, it does so in a temporary file. If you make changes to the contents of any of the 2 panes in WinMerge and save the file, it will not be saved back into the Excel file. +* In Total Commander, navigate to the 1st file in the left-hand pane and the 2nd file in the right-hand pane. +* Press `Ctrl+PageDown` to "enter" the package. You should see, among others, a `[Content_Types].xml` file in both panes. +* You can now compare all package parts by selecting `Commands > Synchronize Dirs...`. Press `Compare`. This will do a full, recursive comparison. You can filter out parts that are identical. +* You can select an item that differs and press `Ctrl+F3` to open the two parts in WinMerge and see the exact comparison of the part's contents. The XML files should automatically reformat/reindent to ease the comparison instead of showing the entire XML contents on a single line. This is the reason for requiring the `DisplayXMLFiles.dll` plugin. +* In Total Commander, you can also navigate to specific files in the left-hand and right-hand panes and select `File > Compare by Content...`. This will open WinMerge directly. +* Note that since WinMerge reformats the XML, it does so in a temporary file. If you make changes to the contents of any of the 2 panes in WinMerge and save the file, it will not be saved back into the Excel file. + +#### Scripted diff preperation + +Powershell script to recursive extract and delete every xlsx in a directory. + +``` Powershell +foreach ($file in Get-ChildItem -Recurse -Filter *.xlsx) + { + cp "$($file.FullName)" "$($file.FullName).zip" + Expand-Archive "$($file.FullName).zip" -DestinationPath "$($file.FullName).unzipped" + rm "$($file.FullName).zip" + rm "$($file.FullName)" + } +``` + +Commands to remove irrelevant XML format before comparing + +``` npm +npm install -g prettier +npm install -g prettier @prettier/plugin-xml +prettier --write '**/*.xml' +``` + +On windows you can call winmerge using + +``` powershell +& "C:\Program Files\WinMerge\WinMergeU.exe" .\Actual\ .\Expected\ +``` ## Code conventions + ClosedXML has a fairly large codebase and we therefore want to keep code revisions as clean and tidy as possible. It is therefore important not to introduce unnecessary whitespace changes in your commits. To ensure you follow the coding conventions, please do the following steps before you commit your code: -- In Visual Studio, run `CodeMaid > Cleanup Active Document` or `Ctrl+M, Space` on each file that you have altered. This will ensure the correct whitespace consistency. -- Some files, not all, have a header in the first line: `// Keep this file CodeMaid organised and cleaned`. For these files, also run `CodeMaid > Reorganize Active Document` or `Ctrl+M, Z`. This will reorder properties and methods alphabetically into a predetermined order. For example, public properties and methods will be organized before private properties and methods. Not all files require this yet. Please take note of the headers. +* In Visual Studio, run `CodeMaid > Cleanup Active Document` or `Ctrl+M, Space` on each file that you have altered. This will ensure the correct whitespace consistency. +* Some files, not all, have a header in the first line: `// Keep this file CodeMaid organized and cleaned`. For these files, also run `CodeMaid > Reorganize Active Document` or `Ctrl+M, Z`. This will reorder properties and methods alphabetically into a predetermined order. For example, public properties and methods will be organized before private properties and methods. Not all files require this yet. Please take note of the headers. diff --git a/ClosedXML.Examples/.editorconfig b/ClosedXML.Examples/.editorconfig new file mode 100644 index 000000000..1f483c3dd --- /dev/null +++ b/ClosedXML.Examples/.editorconfig @@ -0,0 +1,5 @@ +# C# files +[*.cs] + +# S1481: Unused local variables should be removed +dotnet_diagnostic.S1481.severity = none diff --git a/ClosedXML.Examples/AutoFilters/CustomAutoFilter.cs b/ClosedXML.Examples/AutoFilters/CustomAutoFilter.cs index a4e9135cc..2a5bc0785 100644 --- a/ClosedXML.Examples/AutoFilters/CustomAutoFilter.cs +++ b/ClosedXML.Examples/AutoFilters/CustomAutoFilter.cs @@ -1,6 +1,5 @@ -using System; -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -8,11 +7,12 @@ public class CustomAutoFilter : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); IXLWorksheet ws; #region Single Column Numbers - String singleColumnNumbers = "Single Column Numbers"; + + var singleColumnNumbers = "Single Column Numbers"; ws = wb.Worksheets.Add(singleColumnNumbers); // Add a bunch of numbers to filter @@ -29,10 +29,12 @@ public void Create(string filePath) // Sort the filtered list ws.AutoFilter.Sort(1); - #endregion + + #endregion Single Column Numbers #region Single Column Strings - String singleColumnStrings = "Single Column Strings"; + + var singleColumnStrings = "Single Column Strings"; ws = wb.Worksheets.Add(singleColumnStrings); // Add a bunch of strings to filter @@ -49,10 +51,12 @@ public void Create(string filePath) // Sort the filtered list ws.AutoFilter.Sort(1); - #endregion + + #endregion Single Column Strings #region Single Column Mixed - String singleColumnMixed = "Single Column Mixed"; + + var singleColumnMixed = "Single Column Mixed"; ws = wb.Worksheets.Add(singleColumnMixed); // Add a bunch of items to filter @@ -69,10 +73,12 @@ public void Create(string filePath) // Sort the filtered list ws.AutoFilter.Sort(1); - #endregion + + #endregion Single Column Mixed #region Multi Column - String multiColumn = "Multi Column"; + + var multiColumn = "Multi Column"; ws = wb.Worksheets.Add(multiColumn); ws.Cell("A1").SetValue("First") @@ -105,35 +111,42 @@ public void Create(string filePath) // Sort the filtered list ws.AutoFilter.Sort(3); - #endregion - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms); + #endregion Multi Column + + using var ms = new MemoryStream(); + wb.SaveAs(ms); + + using var workbook = new XLWorkbook(ms); - var workbook = new XLWorkbook(ms); + #region Single Column Numbers + + workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); + + #endregion Single Column Numbers + + #region Single Column Strings + + workbook.Worksheet(singleColumnStrings).AutoFilter.Sort(1, XLSortOrder.Descending); - #region Single Column Numbers - workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion + #endregion Single Column Strings - #region Single Column Strings - workbook.Worksheet(singleColumnStrings).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion + #region Single Column Mixed + + workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).EqualOrGreaterThan("D"); + workbook.Worksheet(singleColumnMixed).AutoFilter.Sort(1, XLSortOrder.Descending); + + #endregion Single Column Mixed + + #region Multi Column - #region Single Column Mixed - workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).EqualOrGreaterThan("D"); - workbook.Worksheet(singleColumnMixed).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion + workbook.Worksheet(multiColumn).AutoFilter.Column(3).EqualTo("E"); + workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #region Multi Column - workbook.Worksheet(multiColumn).AutoFilter.Column(3).EqualTo("E"); - workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #endregion + #endregion Multi Column - workbook.SaveAs(filePath); - ms.Close(); - } + workbook.SaveAs(filePath); + ms.Close(); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/AutoFilters/DateTimeGroupAutoFilter.cs b/ClosedXML.Examples/AutoFilters/DateTimeGroupAutoFilter.cs index 6fb3d98cc..db9a156a2 100644 --- a/ClosedXML.Examples/AutoFilters/DateTimeGroupAutoFilter.cs +++ b/ClosedXML.Examples/AutoFilters/DateTimeGroupAutoFilter.cs @@ -7,37 +7,35 @@ public class DateTimeGroupAutoFilter : IXLExample { public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws; + using var wb = new XLWorkbook(); + IXLWorksheet ws; - #region Single Column Dates + #region Single Column Dates - String singleColumnDates = "Single Column Dates"; - ws = wb.Worksheets.Add(singleColumnDates); + var singleColumnDates = "Single Column Dates"; + ws = wb.Worksheets.Add(singleColumnDates); - // Add a bunch of numbers to filter - ws.Cell("A1").SetValue("Dates") - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(2)) - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(3)) - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(3)) - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(5)) - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(1)) - .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(4)); + // Add a bunch of numbers to filter + ws.Cell("A1").SetValue("Dates") + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(2)) + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(3)) + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(3)) + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(5)) + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(1)) + .CellBelow().SetValue(new DateTime(2018, 1, 1).AddDays(4)); - ws.Column(1).Style.NumberFormat.Format = "d MMMM yyyy"; + ws.Column(1).Style.NumberFormat.Format = "d MMMM yyyy"; - // Add filters - ws.RangeUsed().SetAutoFilter().Column(1).AddDateGroupFilter(new DateTime(2018, 1, 1).AddDays(3), XLDateTimeGrouping.Day); + // Add filters + ws.RangeUsed().SetAutoFilter().Column(1).AddDateGroupFilter(new DateTime(2018, 1, 1).AddDays(3), XLDateTimeGrouping.Day); - // Sort the filtered list - ws.AutoFilter.Sort(1); + // Sort the filtered list + ws.AutoFilter.Sort(1); - #endregion Single Column Dates + #endregion Single Column Dates - ws.Columns().AdjustToContents(); - wb.SaveAs(filePath); - } + ws.Columns().AdjustToContents(); + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/AutoFilters/DynamicAutoFilter.cs b/ClosedXML.Examples/AutoFilters/DynamicAutoFilter.cs index 509e18f28..c4d7b9c7d 100644 --- a/ClosedXML.Examples/AutoFilters/DynamicAutoFilter.cs +++ b/ClosedXML.Examples/AutoFilters/DynamicAutoFilter.cs @@ -1,6 +1,5 @@ -using System; -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -8,11 +7,12 @@ public class DynamicAutoFilter : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); IXLWorksheet ws; #region Single Column Numbers - String singleColumnNumbers = "Single Column Numbers"; + + var singleColumnNumbers = "Single Column Numbers"; ws = wb.Worksheets.Add(singleColumnNumbers); // Add a bunch of numbers to filter @@ -29,10 +29,12 @@ public void Create(string filePath) // Sort the filtered list //ws.AutoFilter.Sort(1); - #endregion + + #endregion Single Column Numbers #region Multi Column - String multiColumn = "Multi Column"; + + var multiColumn = "Multi Column"; ws = wb.Worksheets.Add(multiColumn); ws.Cell("A1").SetValue("First") @@ -64,25 +66,28 @@ public void Create(string filePath) // Sort the filtered list //ws.AutoFilter.Sort(3); - #endregion - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms); + #endregion Multi Column + + using var ms = new MemoryStream(); + wb.SaveAs(ms); - var workbook = new XLWorkbook(ms); + using var workbook = new XLWorkbook(ms); + + #region Single Column Numbers + + //workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); + + #endregion Single Column Numbers + + #region Multi Column - #region Single Column Numbers - //workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion + //workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #region Multi Column - //workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #endregion + #endregion Multi Column - workbook.SaveAs(filePath); - ms.Close(); - } + workbook.SaveAs(filePath); + ms.Close(); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/AutoFilters/RegularAutoFilter.cs b/ClosedXML.Examples/AutoFilters/RegularAutoFilter.cs index fc616713e..cfb943b5b 100644 --- a/ClosedXML.Examples/AutoFilters/RegularAutoFilter.cs +++ b/ClosedXML.Examples/AutoFilters/RegularAutoFilter.cs @@ -1,5 +1,4 @@ using ClosedXML.Excel; -using System; using System.IO; namespace ClosedXML.Examples @@ -8,12 +7,12 @@ public class RegularAutoFilter : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); IXLWorksheet ws; #region Single Column Numbers - String singleColumnNumbers = "Single Column Numbers"; + var singleColumnNumbers = "Single Column Numbers"; ws = wb.Worksheets.Add(singleColumnNumbers); // Add a bunch of numbers to filter @@ -49,7 +48,7 @@ public void Create(string filePath) #region Single Column Strings - String singleColumnStrings = "Single Column Strings"; + var singleColumnStrings = "Single Column Strings"; ws = wb.Worksheets.Add(singleColumnStrings); // Add a bunch of strings to filter @@ -72,7 +71,7 @@ public void Create(string filePath) #region Single Column Mixed - String singleColumnMixed = "Single Column Mixed"; + var singleColumnMixed = "Single Column Mixed"; ws = wb.Worksheets.Add(singleColumnMixed); // Add a bunch of items to filter @@ -95,7 +94,7 @@ public void Create(string filePath) #region Multi Column - String multiColumn = "Multi Column"; + var multiColumn = "Multi Column"; ws = wb.Worksheets.Add(multiColumn); ws.Cell("A1").SetValue("First") @@ -133,7 +132,7 @@ public void Create(string filePath) #region Table - String tableSheetName = "Table"; + var tableSheetName = "Table"; ws = wb.Worksheets.Add(tableSheetName); // Add a bunch of numbers to filter @@ -155,51 +154,49 @@ public void Create(string filePath) #endregion Table - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms); + using var ms = new MemoryStream(); + wb.SaveAs(ms); - var workbook = new XLWorkbook(ms); + using var workbook = new XLWorkbook(ms); - #region Single Column Numbers + #region Single Column Numbers - workbook.Worksheet(singleColumnNumbers).AutoFilter.Column(1).AddFilter(5); - workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); + workbook.Worksheet(singleColumnNumbers).AutoFilter.Column(1).AddFilter(5); + workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion Single Column Numbers + #endregion Single Column Numbers - #region Single Column Strings + #region Single Column Strings - workbook.Worksheet(singleColumnStrings).AutoFilter.Column(1).AddFilter("E"); - workbook.Worksheet(singleColumnStrings).AutoFilter.Sort(1, XLSortOrder.Descending); + workbook.Worksheet(singleColumnStrings).AutoFilter.Column(1).AddFilter("E"); + workbook.Worksheet(singleColumnStrings).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion Single Column Strings + #endregion Single Column Strings - #region Single Column Mixed + #region Single Column Mixed - workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).AddFilter("E"); - workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).AddFilter(3); - workbook.Worksheet(singleColumnMixed).AutoFilter.Sort(1, XLSortOrder.Descending); + workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).AddFilter("E"); + workbook.Worksheet(singleColumnMixed).AutoFilter.Column(1).AddFilter(3); + workbook.Worksheet(singleColumnMixed).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion Single Column Mixed + #endregion Single Column Mixed - #region Multi Column + #region Multi Column - workbook.Worksheet(multiColumn).AutoFilter.Column(3).AddFilter("C"); - workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); + workbook.Worksheet(multiColumn).AutoFilter.Column(3).AddFilter("C"); + workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #endregion Multi Column + #endregion Multi Column - #region Table + #region Table - workbook.Worksheet(tableSheetName).Table(0).AutoFilter.Column(1).AddFilter(5); - workbook.Worksheet(tableSheetName).Table(0).AutoFilter.Sort(1, XLSortOrder.Descending); + workbook.Worksheet(tableSheetName).Table(0).AutoFilter.Column(1).AddFilter(5); + workbook.Worksheet(tableSheetName).Table(0).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion Table + #endregion Table - workbook.SaveAs(filePath); - ms.Close(); - } + workbook.SaveAs(filePath); + ms.Close(); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/AutoFilters/TopBottomAutoFilter.cs b/ClosedXML.Examples/AutoFilters/TopBottomAutoFilter.cs index 649760da5..3fe110f56 100644 --- a/ClosedXML.Examples/AutoFilters/TopBottomAutoFilter.cs +++ b/ClosedXML.Examples/AutoFilters/TopBottomAutoFilter.cs @@ -1,6 +1,5 @@ -using System; -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -8,11 +7,12 @@ public class TopBottomAutoFilter : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); IXLWorksheet ws; #region Single Column Numbers - String singleColumnNumbers = "Single Column Numbers"; + + var singleColumnNumbers = "Single Column Numbers"; ws = wb.Worksheets.Add(singleColumnNumbers); // Add a bunch of numbers to filter @@ -29,10 +29,12 @@ public void Create(string filePath) // Sort the filtered list //ws.AutoFilter.Sort(1); - #endregion + + #endregion Single Column Numbers #region Multi Column - String multiColumn = "Multi Column"; + + var multiColumn = "Multi Column"; ws = wb.Worksheets.Add(multiColumn); ws.Cell("A1").SetValue("First") @@ -64,25 +66,28 @@ public void Create(string filePath) // Sort the filtered list //ws.AutoFilter.Sort(3); - #endregion - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms); + #endregion Multi Column + + using var ms = new MemoryStream(); + wb.SaveAs(ms); - var workbook = new XLWorkbook(ms); + using var workbook = new XLWorkbook(ms); + + #region Single Column Numbers + + //workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); + + #endregion Single Column Numbers + + #region Multi Column - #region Single Column Numbers - //workbook.Worksheet(singleColumnNumbers).AutoFilter.Sort(1, XLSortOrder.Descending); - #endregion + //workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #region Multi Column - //workbook.Worksheet(multiColumn).AutoFilter.Sort(3, XLSortOrder.Descending); - #endregion + #endregion Multi Column - workbook.SaveAs(filePath); - ms.Close(); - } + workbook.SaveAs(filePath); + ms.Close(); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/BasicTable.cs b/ClosedXML.Examples/BasicTable.cs index b60cdd7b4..480d8a5fc 100644 --- a/ClosedXML.Examples/BasicTable.cs +++ b/ClosedXML.Examples/BasicTable.cs @@ -8,7 +8,7 @@ public class BasicTable : IXLExample public void Create(string filePath) { // Creating a new workbook - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); //Adding a worksheet var ws = wb.Worksheets.Add("Contacts"); @@ -90,4 +90,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/ClosedXML.Examples.csproj b/ClosedXML.Examples/ClosedXML.Examples.csproj index 63cefd651..4c3bb03df 100644 --- a/ClosedXML.Examples/ClosedXML.Examples.csproj +++ b/ClosedXML.Examples/ClosedXML.Examples.csproj @@ -1,43 +1,29 @@  + + net6.0;net48 + net6.0 + 8.0 + Exe + 0.95.2 + Debug;Release + false + true + ..\ClosedXML.snk + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + - - netcoreapp3.1;net40;net46 - 8.0 - Exe - 0.95.4 - $(NoWarn);NU1605 - Debug;Release - true - ..\ClosedXML.snk - ClosedXML.Examples - ClosedXML.Examples - - - - $(DefineConstants);_NETSTANDARD_;_NETSTANDARD2_0_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET40_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET46_ - - - - - - - - - - - - - - - - diff --git a/ClosedXML.Examples/Columns/ColumnCells.cs b/ClosedXML.Examples/Columns/ColumnCells.cs index 4a10c8dd9..1293f72cd 100644 --- a/ClosedXML.Examples/Columns/ColumnCells.cs +++ b/ClosedXML.Examples/Columns/ColumnCells.cs @@ -1,15 +1,12 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples { public class ColumnCells : IXLExample { - - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Column Cells"); var columnFromWorksheet = ws.Column(1); @@ -27,6 +24,5 @@ public void Create(String filePath) workbook.SaveAs(filePath); } - } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Columns/ColumnCollections.cs b/ClosedXML.Examples/Columns/ColumnCollections.cs index 61d7792e5..c9d764c41 100644 --- a/ClosedXML.Examples/Columns/ColumnCollections.cs +++ b/ClosedXML.Examples/Columns/ColumnCollections.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Columns { public class ColumnCollection : IXLExample @@ -12,8 +10,7 @@ public class ColumnCollection : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,9 +20,7 @@ public class ColumnCollection : IXLExample // Override - - #endregion - + #endregion Properties #region Events @@ -35,15 +30,14 @@ public class ColumnCollection : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Columns of a Range"); // All columns in a range @@ -70,10 +64,10 @@ public void Create(String filePath) bigRange.Columns("V").Style.Fill.BackgroundColor = XLColor.Cyan; // Adjust the width - ws.Columns("A:V").Width = 3; + ws.Columns("A:V").Width = 3; var ws2 = workbook.Worksheets.Add("Columns of a worksheet"); - + // Contiguous columns by number ws2.Columns(1, 2).Style.Fill.BackgroundColor = XLColor.Red; @@ -94,7 +88,7 @@ public void Create(String filePath) // Adjust the width ws2.Columns("A:V").Width = 3; - + workbook.SaveAs(filePath); } @@ -102,7 +96,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Columns/ColumnSettings.cs b/ClosedXML.Examples/Columns/ColumnSettings.cs index 88035f1b0..e7bbaea70 100644 --- a/ClosedXML.Examples/Columns/ColumnSettings.cs +++ b/ClosedXML.Examples/Columns/ColumnSettings.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Columns { public class ColumnSettings : IXLExample @@ -12,8 +10,7 @@ public class ColumnSettings : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,22 +20,18 @@ public class ColumnSettings : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public public ColumnSettings() { - } - // Private - - #endregion + #endregion Constructors #region Events @@ -48,15 +41,14 @@ public ColumnSettings() // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Column Settings"); var col1 = ws.Column("B"); @@ -74,7 +66,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Columns/DeletingColumns.cs b/ClosedXML.Examples/Columns/DeletingColumns.cs index cf741d2fe..40aa6aa37 100644 --- a/ClosedXML.Examples/Columns/DeletingColumns.cs +++ b/ClosedXML.Examples/Columns/DeletingColumns.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples { public class DeletingColumns : IXLExample @@ -12,8 +10,7 @@ public class DeletingColumns : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class DeletingColumns : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class DeletingColumns : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Deleting Columns"); var rngTitles = ws.Range("B2:D2"); @@ -69,7 +64,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Columns/InsertColumns.cs b/ClosedXML.Examples/Columns/InsertColumns.cs index 747857c46..289c30e8a 100644 --- a/ClosedXML.Examples/Columns/InsertColumns.cs +++ b/ClosedXML.Examples/Columns/InsertColumns.cs @@ -1,14 +1,13 @@ using ClosedXML.Excel; -using System; using System.Linq; namespace ClosedXML.Examples.Columns { public class InsertColumns : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Inserting Columns"); // Color the entire spreadsheet using columns @@ -16,8 +15,12 @@ public void Create(String filePath) // Put a value in a few cells foreach (var r in Enumerable.Range(1, 5)) + { foreach (var c in Enumerable.Range(1, 5)) + { ws.Cell(r, c).Value = "X"; + } + } var blueColumn = ws.Column(2); var redColumn = ws.Column(5); @@ -37,4 +40,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Comments/AddingComments.cs b/ClosedXML.Examples/Comments/AddingComments.cs index 6b56fe21f..1f3ecbbdc 100644 --- a/ClosedXML.Examples/Comments/AddingComments.cs +++ b/ClosedXML.Examples/Comments/AddingComments.cs @@ -1,19 +1,13 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; using ClosedXML.Excel; -using System.IO; using MoreLinq; -namespace ClosedXML.Examples +namespace ClosedXML.Examples { - public class AddingComments : IXLExample + public class AddingComments : IXLExample { - public void Create(string filePath) { - var wb = new XLWorkbook {Author = "Manuel"}; + using var wb = new XLWorkbook { Author = "Manuel" }; AddMiscComments(wb); AddVisibilityComments(wb); AddPosition(wb); @@ -147,7 +141,6 @@ private void AddStyleAlignment(XLWorkbook wb) .Alignment.SetOrientation(XLDrawingTextOrientation.Vertical) .Alignment.SetAutomaticSize(); - // Set all comments to visible ws.CellsUsed(XLCellsUsedOptions.All, c => c.HasComment).ForEach(c => c.GetComment().SetVisible()); } @@ -228,7 +221,7 @@ private static void AddVisibilityComments(XLWorkbook wb) // By default comments are hidden ws.Cell("A1").SetValue("I have a hidden comment").GetComment().AddText("Hidden"); - + // Set the comment as visible ws.Cell("A2").GetComment().SetVisible().AddText("Visible"); @@ -240,7 +233,7 @@ private static void AddVisibilityComments(XLWorkbook wb) // so we set the ZOrder to something lower ws.Cell("A4").GetComment().SetZOrder(4).SetVisible().AddText("Underneath"); ws.Cell("A4").GetComment().Style.Alignment.SetVertical(XLDrawingVerticalAlignment.Bottom); - + // Alternatively you could set all comments to visible with the following line: // ws.CellsUsed(true, c => c.HasComment).ForEach(c => c.Comment.SetVisible()); @@ -250,7 +243,7 @@ private static void AddVisibilityComments(XLWorkbook wb) private void AddPosition(XLWorkbook wb) { var ws = wb.Worksheets.Add("Position"); - + ws.Columns().Width = 10; ws.Cell("A1").GetComment().AddText("This is an unusual place for a comment..."); @@ -276,10 +269,9 @@ private void AddSignatures(XLWorkbook wb) .SetAuthor("MDeLeon") .AddSignature() .AddText("Hello World!"); - // Set all comments to visible ws.CellsUsed(XLCellsUsedOptions.All, c => c.HasComment).ForEach(c => c.GetComment().SetVisible()); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Comments/EditingComments.cs b/ClosedXML.Examples/Comments/EditingComments.cs index 37c42d898..df82c981f 100644 --- a/ClosedXML.Examples/Comments/EditingComments.cs +++ b/ClosedXML.Examples/Comments/EditingComments.cs @@ -1,27 +1,20 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; using ClosedXML.Excel; using System.IO; -namespace ClosedXML.Examples +namespace ClosedXML.Examples { - class EditingComments : IXLExample + internal class EditingComments : IXLExample { - - public void Create(string filePath) { - + public void Create(string filePath) + { // Exercise(@"path/to/test/resources/comments"); - } - public void Exercise(string basePath) + public void Exercise(string basePath) { - // INCOMPLETE - var book = new XLWorkbook(Path.Combine(basePath, "EditingComments.xlsx")); + using var book = new XLWorkbook(Path.Combine(basePath, "EditingComments.xlsx")); var sheet = book.Worksheet(1); // no change @@ -52,4 +45,4 @@ public void Exercise(string basePath) book.SaveAs(Path.Combine(basePath, "EditingComments_modified.xlsx")); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/ConditionalFormatting/ConditionalFormatting.cs b/ClosedXML.Examples/ConditionalFormatting/ConditionalFormatting.cs index 303f5638e..dbb2e08d9 100644 --- a/ClosedXML.Examples/ConditionalFormatting/ConditionalFormatting.cs +++ b/ClosedXML.Examples/ConditionalFormatting/ConditionalFormatting.cs @@ -1,13 +1,12 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples { public class CFColorScaleLowMidHigh : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -26,9 +25,9 @@ public void Create(String filePath) public class CFColorScaleLowHigh : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -46,9 +45,9 @@ public void Create(String filePath) public class CFColorScaleMinimumMaximum : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -66,9 +65,9 @@ public void Create(String filePath) public class CFStartsWith : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -88,9 +87,9 @@ public void Create(String filePath) public class CFEndsWith : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -107,9 +106,9 @@ public void Create(String filePath) public class CFIsBlank : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -126,9 +125,9 @@ public void Create(String filePath) public class CFNotBlank : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -145,9 +144,9 @@ public void Create(String filePath) public class CFIsError : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -164,9 +163,9 @@ public void Create(String filePath) public class CFNotError : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -183,9 +182,9 @@ public void Create(String filePath) public class CFContains : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -202,9 +201,9 @@ public void Create(String filePath) public class CFNotContains : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -221,9 +220,9 @@ public void Create(String filePath) public class CFEqualsString : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -240,9 +239,9 @@ public void Create(String filePath) public class CFEqualsNumber : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -259,9 +258,9 @@ public void Create(String filePath) public class CFNotEqualsString : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Hello") @@ -278,9 +277,9 @@ public void Create(String filePath) public class CFNotEqualsNumber : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -297,9 +296,9 @@ public void Create(String filePath) public class CFGreaterThan : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -316,9 +315,9 @@ public void Create(String filePath) public class CFEqualOrGreaterThan : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -335,9 +334,9 @@ public void Create(String filePath) public class CFLessThan : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -354,9 +353,9 @@ public void Create(String filePath) public class CFEqualOrLessThan : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -373,9 +372,9 @@ public void Create(String filePath) public class CFBetween : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -392,9 +391,9 @@ public void Create(String filePath) public class CFNotBetween : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -411,9 +410,9 @@ public void Create(String filePath) public class CFUnique : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -430,9 +429,9 @@ public void Create(String filePath) public class CFDuplicate : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -449,9 +448,9 @@ public void Create(String filePath) public class CFIsTrue : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -468,9 +467,9 @@ public void Create(String filePath) public class CFTop : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -487,9 +486,9 @@ public void Create(String filePath) public class CFBottom : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -506,9 +505,9 @@ public void Create(String filePath) public class CFDataBar : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -526,9 +525,9 @@ public void Create(String filePath) public class CFDataBarNegative : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.Cell(1, 1).SetValue(-1) @@ -559,9 +558,9 @@ public void Create(String filePath) public class CFIconSet : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -580,9 +579,9 @@ public void Create(String filePath) public class CFTwoConditions : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -604,9 +603,9 @@ public void Create(String filePath) public class CFInsertRows : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.Cell(2, 1).SetValue(1) @@ -624,9 +623,9 @@ public void Create(String filePath) public class CFTest : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1) @@ -645,9 +644,9 @@ public void Create(String filePath) public class CFMultipleConditions : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); var range = ws.Range("A1:A10"); @@ -664,9 +663,9 @@ public void Create(String filePath) public class CFStopIfTrue : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(6) @@ -687,31 +686,29 @@ public void Create(String filePath) public class CFDatesOccurring : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - using (var workbook = new XLWorkbook()) - { - var ws = workbook.AddWorksheet("Sheet1"); + using var workbook = new XLWorkbook(); + var ws = workbook.AddWorksheet("Sheet1"); - var range = ws.Range("A1:A10"); - range.AddConditionalFormat() - .WhenDateIs(XLTimePeriod.Tomorrow) - .Fill.SetBackgroundColor(XLColor.GrannySmithApple); + var range = ws.Range("A1:A10"); + range.AddConditionalFormat() + .WhenDateIs(XLTimePeriod.Tomorrow) + .Fill.SetBackgroundColor(XLColor.GrannySmithApple); - range.AddConditionalFormat() - .WhenDateIs(XLTimePeriod.Yesterday) - .Fill.SetBackgroundColor(XLColor.Orange); + range.AddConditionalFormat() + .WhenDateIs(XLTimePeriod.Yesterday) + .Fill.SetBackgroundColor(XLColor.Orange); - range.AddConditionalFormat() - .WhenDateIs(XLTimePeriod.InTheLast7Days) - .Fill.SetBackgroundColor(XLColor.Blue); + range.AddConditionalFormat() + .WhenDateIs(XLTimePeriod.InTheLast7Days) + .Fill.SetBackgroundColor(XLColor.Blue); - range.AddConditionalFormat() - .WhenDateIs(XLTimePeriod.ThisMonth) - .Fill.SetBackgroundColor(XLColor.Red); + range.AddConditionalFormat() + .WhenDateIs(XLTimePeriod.ThisMonth) + .Fill.SetBackgroundColor(XLColor.Red); - workbook.SaveAs(filePath); - } + workbook.SaveAs(filePath); } } @@ -729,7 +726,7 @@ public void Create(string filePath) ws.Cell("A1").Value = "Automatic"; ws.Range("A2:A6").AddConditionalFormat().DataBar(XLColor.Amber); - + ws.Cell("B1").Value = "Lowest/Highest"; ws.Range("B2:B6").AddConditionalFormat().DataBar(XLColor.BallBlue) .LowestValue() @@ -754,8 +751,8 @@ public void Create(string filePath) ws.Range("F2:F6").AddConditionalFormat().DataBar(XLColor.Fandango) .Minimum(XLCFContentType.Percentile, 30) .Maximum(XLCFContentType.Percentile, 70); - + workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Delete/DeleteFewWorksheets.cs b/ClosedXML.Examples/Delete/DeleteFewWorksheets.cs index dbf0fdf1b..e8d255ee0 100644 --- a/ClosedXML.Examples/Delete/DeleteFewWorksheets.cs +++ b/ClosedXML.Examples/Delete/DeleteFewWorksheets.cs @@ -1,18 +1,18 @@ -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples.Delete { - public class DeleteFewWorksheets:IXLExample + public class DeleteFewWorksheets : IXLExample { public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { //Note: Prepare { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); workbook.Worksheets.Add("1"); workbook.Worksheets.Add("2"); workbook.Worksheets.Add("3"); @@ -20,9 +20,9 @@ public void Create(string filePath) workbook.SaveAs(tempFile); } - //Note: Delate few worksheet + //Note: Delete few worksheet { - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); workbook.Worksheets.Delete("1"); workbook.Worksheets.Delete("2"); workbook.SaveAs(filePath); @@ -35,7 +35,6 @@ public void Create(string filePath) File.Delete(tempFile); } } - } } } \ No newline at end of file diff --git a/ClosedXML.Examples/Delete/DeleteRows.cs b/ClosedXML.Examples/Delete/DeleteRows.cs index 0d572796c..8a3397f5b 100644 --- a/ClosedXML.Examples/Delete/DeleteRows.cs +++ b/ClosedXML.Examples/Delete/DeleteRows.cs @@ -1,7 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.Delete { @@ -13,8 +11,7 @@ public class DeleteRows : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -24,8 +21,7 @@ public class DeleteRows : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -35,24 +31,27 @@ public class DeleteRows : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { #region Create case + { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Delete red rows"); // Put a value in a few cells foreach (var r in Enumerable.Range(1, 5)) + { foreach (var c in Enumerable.Range(1, 5)) + { ws.Cell(r, c).Value = string.Format("R{0}C{1}", r, c); - + } + } var blueRow = ws.Rows(1, 2); var redRow = ws.Row(5); @@ -62,25 +61,26 @@ public void Create(String filePath) redRow.Style.Fill.BackgroundColor = XLColor.Red; workbook.SaveAs(filePath); } - #endregion + + #endregion Create case #region Remove rows + { - var workbook = new XLWorkbook(filePath); + using var workbook = new XLWorkbook(filePath); var ws = workbook.Worksheets.Worksheet("Delete red rows"); ws.Rows(1, 2).Delete(); workbook.Save(); } - #endregion + #endregion Remove rows } // Private // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/HelloWorld.cs b/ClosedXML.Examples/HelloWorld.cs index 3f70ac2f5..9deacd562 100644 --- a/ClosedXML.Examples/HelloWorld.cs +++ b/ClosedXML.Examples/HelloWorld.cs @@ -1,16 +1,15 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples { public class HelloWorld { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sample Sheet"); worksheet.Cell("A1").Value = "Hello World!"; workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/ImageHandling/ImageAnchors.cs b/ClosedXML.Examples/ImageHandling/ImageAnchors.cs index cd5696639..71ee56362 100644 --- a/ClosedXML.Examples/ImageHandling/ImageAnchors.cs +++ b/ClosedXML.Examples/ImageHandling/ImageAnchors.cs @@ -1,6 +1,5 @@ using ClosedXML.Excel; using ClosedXML.Excel.Drawings; -using System.IO; using System.Reflection; namespace ClosedXML.Examples @@ -9,76 +8,74 @@ public class ImageAnchors : IXLExample { public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws; - - using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.png")) - { - ws = wb.Worksheets.Add("Images1"); + using var wb = new XLWorkbook(); + IXLWorksheet ws; - #region AbsoluteAnchor + using (var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.png")) + { + ws = wb.Worksheets.Add("Images1"); - ws.AddPicture(fs, XLPictureFormat.Png, "Image10") - .MoveTo(220, 150); + #region AbsoluteAnchor - #endregion AbsoluteAnchor + ws.AddPicture(fs, XLPictureFormat.Png, "Image10") + .MoveTo(220, 150); - #region OneCellAnchor + #endregion AbsoluteAnchor - fs.Position = 0; - ws.AddPicture(fs, XLPictureFormat.Png, "Image11") - .MoveTo(ws.Cell(1, 1)); + #region OneCellAnchor - #endregion OneCellAnchor + fs.Position = 0; + ws.AddPicture(fs, XLPictureFormat.Png, "Image11") + .MoveTo(ws.Cell(1, 1)); - ws = wb.Worksheets.Add("Images2"); + #endregion OneCellAnchor - #region TwoCellAnchor + ws = wb.Worksheets.Add("Images2"); - fs.Position = 0; - ws.AddPicture(fs, XLPictureFormat.Png, "Image20") - .MoveTo(ws.Cell(6, 5), ws.Cell(9, 7)); + #region TwoCellAnchor - #endregion TwoCellAnchor - } + fs.Position = 0; + ws.AddPicture(fs, XLPictureFormat.Png, "Image20") + .MoveTo(ws.Cell(6, 5), ws.Cell(9, 7)); - using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - { - // Moving images around and scaling them - ws = wb.Worksheets.Add("Images3"); + #endregion TwoCellAnchor + } - ws.AddPicture(fs, XLPictureFormat.Jpeg) - .MoveTo(ws.Cell(2, 2), 20, 5, ws.Cell(5, 5), 30, 10) - .MoveTo(ws.Cell(2, 2), ws.Cell(5, 5)); + using (var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) + { + // Moving images around and scaling them + ws = wb.Worksheets.Add("Images3"); - ws.AddPicture(fs, XLPictureFormat.Jpeg) - .MoveTo(ws.Cell(6, 2), 2, 2, ws.Cell(9, 5), 2, 2) - .MoveTo(ws.Cell(6, 2), 20, 5, ws.Cell(9, 5), 30, 10); + ws.AddPicture(fs, XLPictureFormat.Jpeg) + .MoveTo(ws.Cell(2, 2), 20, 5, ws.Cell(5, 5), 30, 10) + .MoveTo(ws.Cell(2, 2), ws.Cell(5, 5)); - ws.AddPicture(fs, XLPictureFormat.Jpeg) - .MoveTo(ws.Cell(10, 2), 20, 5) - .Scale(0.2, true) - .MoveTo(ws.Cell(10, 1)); - } + ws.AddPicture(fs, XLPictureFormat.Jpeg) + .MoveTo(ws.Cell(6, 2), 2, 2, ws.Cell(9, 5), 2, 2) + .MoveTo(ws.Cell(6, 2), 20, 5, ws.Cell(9, 5), 30, 10); - using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - { - // Changing of placement - ws = wb.Worksheets.Add("Images4"); + ws.AddPicture(fs, XLPictureFormat.Jpeg) + .MoveTo(ws.Cell(10, 2), 20, 5) + .Scale(0.2, true) + .MoveTo(ws.Cell(10, 1)); + } - ws.AddPicture(fs, XLPictureFormat.Jpeg) - .MoveTo(100, 100) - .WithPlacement(XLPicturePlacement.FreeFloating); + using (var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) + { + // Changing of placement + ws = wb.Worksheets.Add("Images4"); - // Add and delete picture immediately - ws.AddPicture(fs, XLPictureFormat.Jpeg) - .MoveTo(100, 600) - .Delete(); - } + ws.AddPicture(fs, XLPictureFormat.Jpeg) + .MoveTo(100, 100) + .WithPlacement(XLPicturePlacement.FreeFloating); - wb.SaveAs(filePath); + // Add and delete picture immediately + ws.AddPicture(fs, XLPictureFormat.Jpeg) + .MoveTo(100, 600) + .Delete(); } + + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/ImageHandling/ImageFormats.cs b/ClosedXML.Examples/ImageHandling/ImageFormats.cs index 96debfa68..4512577b4 100644 --- a/ClosedXML.Examples/ImageHandling/ImageFormats.cs +++ b/ClosedXML.Examples/ImageHandling/ImageFormats.cs @@ -1,6 +1,5 @@ using ClosedXML.Excel; using ClosedXML.Excel.Drawings; -using System.IO; using System.Reflection; namespace ClosedXML.Examples @@ -9,10 +8,10 @@ public class ImageFormats : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); IXLWorksheet ws; - using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.jpg")) + using (var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.jpg")) { #region Jpeg @@ -23,7 +22,7 @@ public void Create(string filePath) #endregion Jpeg } - using (Stream fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.png")) + using (var fs = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Examples.Resources.ImageHandling.png")) { #region Png @@ -37,4 +36,4 @@ public void Create(string filePath) } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Loading/ChangingBasicTable.cs b/ClosedXML.Examples/Loading/ChangingBasicTable.cs index 26918e42c..f4e4615d8 100644 --- a/ClosedXML.Examples/Loading/ChangingBasicTable.cs +++ b/ClosedXML.Examples/Loading/ChangingBasicTable.cs @@ -1,6 +1,5 @@ -using System.IO; using ClosedXML.Excel; - +using System.IO; namespace ClosedXML.Examples { @@ -8,11 +7,11 @@ public class ChangingBasicTable : IXLExample { public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); // Change the background color of the headers @@ -27,7 +26,7 @@ public void Create(string filePath) var rngNumbers = ws.Range("F4:F6"); foreach (var cell in rngNumbers.Cells()) { - string formattedString = cell.GetFormattedString(); + var formattedString = cell.GetFormattedString(); cell.DataType = XLDataType.Text; cell.Value = formattedString + " Dollars"; } diff --git a/ClosedXML.Examples/Loading/LoadFiles.cs b/ClosedXML.Examples/Loading/LoadFiles.cs index 0b56a9f71..789e0ef3d 100644 --- a/ClosedXML.Examples/Loading/LoadFiles.cs +++ b/ClosedXML.Examples/Loading/LoadFiles.cs @@ -1,6 +1,5 @@ -using System; -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -16,9 +15,9 @@ public static void LoadAllFiles() } } - private static void LoadAndSaveFile(String input, String output) + private static void LoadAndSaveFile(string input, string output) { - var wb = new XLWorkbook(input); + using var wb = new XLWorkbook(input); wb.SaveAs(output); wb.SaveAs(output); } diff --git a/ClosedXML.Examples/Misc/AddingDataSet.cs b/ClosedXML.Examples/Misc/AddingDataSet.cs index fd6a20d26..82c5e5e71 100644 --- a/ClosedXML.Examples/Misc/AddingDataSet.cs +++ b/ClosedXML.Examples/Misc/AddingDataSet.cs @@ -1,23 +1,24 @@ using ClosedXML.Excel; using System; using System.Data; -using System.Linq; namespace ClosedXML.Examples.Misc { public class AddingDataSet : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); - var dataSet = GetDataSet(); + using var dataSet = GetDataSet(); // Add all DataTables in the DataSet as a worksheets wb.Worksheets.Add(dataSet); foreach (var ws in wb.Worksheets) + { ws.Columns().AdjustToContents(); + } wb.SaveAs(filePath); } @@ -31,10 +32,12 @@ private DataSet GetDataSet() return ds; } - private DataTable GetTable(String tableName) + private DataTable GetTable(string tableName) { - DataTable table = new DataTable(); - table.TableName = tableName; + var table = new DataTable + { + TableName = tableName + }; table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -48,4 +51,4 @@ private DataTable GetTable(String tableName) return table; } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/AddingDataTableAsWorksheet.cs b/ClosedXML.Examples/Misc/AddingDataTableAsWorksheet.cs index 5ab16daf0..9b78fc275 100644 --- a/ClosedXML.Examples/Misc/AddingDataTableAsWorksheet.cs +++ b/ClosedXML.Examples/Misc/AddingDataTableAsWorksheet.cs @@ -1,7 +1,7 @@ +using ClosedXML.Excel; using System; using System.Data; using System.Linq; -using ClosedXML.Excel; namespace ClosedXML.Examples.Misc { @@ -13,8 +13,7 @@ public class AddingDataTableAsWorksheet : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -24,8 +23,7 @@ public class AddingDataTableAsWorksheet : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -35,17 +33,16 @@ public class AddingDataTableAsWorksheet : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); - var dataTable = GetTable("Information"); + using var dataTable = GetTable("Information"); // Add a DataTable as a worksheet wb.Worksheets.Add(dataTable); @@ -55,10 +52,12 @@ public void Create(String filePath) } // Private - private DataTable GetTable(String tableName) + private DataTable GetTable(string tableName) { - DataTable table = new DataTable(); - table.TableName = tableName; + var table = new DataTable + { + TableName = tableName + }; table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -73,7 +72,6 @@ private DataTable GetTable(String tableName) } // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/AdjustToContents.cs b/ClosedXML.Examples/Misc/AdjustToContents.cs index 4b149a043..e3897b32b 100644 --- a/ClosedXML.Examples/Misc/AdjustToContents.cs +++ b/ClosedXML.Examples/Misc/AdjustToContents.cs @@ -1,113 +1,110 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { public class AdjustToContents : IXLExample { // Public - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Adjust To Contents"); + + // Set some values with different font sizes + ws.Cell(1, 1).Value = "Tall Row"; + ws.Cell(1, 1).Style.Font.FontSize = 30; + ws.Cell(2, 1).Value = "Very Wide Column"; + ws.Cell(2, 1).Style.Font.FontSize = 20; + + // Adjust column width + ws.Column(1).AdjustToContents(); + + // Adjust row heights + ws.Rows(1, 2).AdjustToContents(); + + // You can also adjust all rows/columns in one shot + // ws.Rows().AdjustToContents(); + // ws.Columns().AdjustToContents(); + + // We'll now select which cells should be used for calculating the + // column widths (same method applies for row heights) + + // Set the values + ws.Cell(4, 2).Value = "Width ignored because calling column.AdjustToContents(5, 7)"; + ws.Cell(5, 2).Value = "Short text"; + ws.Cell(6, 2).Value = "Width ignored because it's part of a merge"; + ws.Range(6, 2, 6, 4).Merge(); + ws.Cell(7, 2).Value = "Width should adjust to this cell"; + ws.Cell(8, 2).Value = "Width ignored because calling column.AdjustToContents(5, 7)"; + + // Adjust column widths only taking into account rows 5-7 + // (merged cells will be ignored) + ws.Column(2).AdjustToContents(5, 7); + + // You can also specify the starting row to start calculating the widths: + // e.g. ws.Column(3).AdjustToContents(9); + + var ws2 = wb.Worksheets.Add("Adjust Widths"); + ws2.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; + for (var co = 0; co < 90; co += 5) { - var ws = wb.Worksheets.Add("Adjust To Contents"); - - // Set some values with different font sizes - ws.Cell(1, 1).Value = "Tall Row"; - ws.Cell(1, 1).Style.Font.FontSize = 30; - ws.Cell(2, 1).Value = "Very Wide Column"; - ws.Cell(2, 1).Style.Font.FontSize = 20; - - // Adjust column width - ws.Column(1).AdjustToContents(); - - // Adjust row heights - ws.Rows(1, 2).AdjustToContents(); - - // You can also adjust all rows/columns in one shot - // ws.Rows().AdjustToContents(); - // ws.Columns().AdjustToContents(); - - // We'll now select which cells should be used for calculating the - // column widths (same method applies for row heights) - - // Set the values - ws.Cell(4, 2).Value = "Width ignored because calling column.AdjustToContents(5, 7)"; - ws.Cell(5, 2).Value = "Short text"; - ws.Cell(6, 2).Value = "Width ignored because it's part of a merge"; - ws.Range(6, 2, 6, 4).Merge(); - ws.Cell(7, 2).Value = "Width should adjust to this cell"; - ws.Cell(8, 2).Value = "Width ignored because calling column.AdjustToContents(5, 7)"; - - // Adjust column widths only taking into account rows 5-7 - // (merged cells will be ignored) - ws.Column(2).AdjustToContents(5, 7); - - // You can also specify the starting row to start calculating the widths: - // e.g. ws.Column(3).AdjustToContents(9); - - var ws2 = wb.Worksheets.Add("Adjust Widths"); - ws2.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; - for (Int32 co = 0; co < 90; co += 5) - { - ws2.Cell(1, (co / 5) + 2).SetValue("Text to adjust - " + co).Style.Alignment.TextRotation = co; - } - - ws2.Columns().AdjustToContents(); - - var ws4 = wb.Worksheets.Add("Adjust Widths 2"); - ws4.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; - for (Int32 co = 0; co < 90; co += 5) - { - var c = ws4.Cell(1, (co / 5) + 2); - - c.GetRichText().AddText("Text to adjust - " + co).SetBold(); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("World!").SetBold().SetFontColor(XLColor.Blue).SetFontSize(25); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("Hello Cruel and unsusual world").SetBold().SetFontSize(20); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("Hello").SetBold(); - c.Style.Alignment.SetTextRotation(co); - } - ws4.Columns().AdjustToContents(); - - var ws3 = wb.Worksheets.Add("Adjust Heights"); - ws3.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; - for (Int32 ro = 0; ro < 90; ro += 5) - { - ws3.Cell((ro / 5) + 2, 1).SetValue("Text to adjust - " + ro).Style.Alignment.TextRotation = ro; - } - - ws3.Rows().AdjustToContents(); - - var ws5 = wb.Worksheets.Add("Adjust Heights 2"); - ws5.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; - for (Int32 ro = 0; ro < 90; ro += 5) - { - var c = ws5.Cell((ro / 5) + 2, 1); - c.GetRichText().AddText("Text to adjust - " + ro).SetBold(); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("World!").SetBold().SetFontColor(XLColor.Blue).SetFontSize(10); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("Hello Cruel and unsusual world").SetBold().SetFontSize(15); - c.GetRichText().AddText(Environment.NewLine); - c.GetRichText().AddText("Hello").SetBold(); - c.Style.Alignment.SetTextRotation(ro); - } - - ws5.Rows().AdjustToContents(); - - var ws6 = wb.Worksheets.Add("Absurdly wide column"); - ws6.Cell("A1").Value = "Some string"; - - // This column's width should be capped at 255 - ws6.Cell("B1").Value = @"Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."; - - ws6.Columns().AdjustToContents(); - - wb.SaveAs(filePath, true); + ws2.Cell(1, (co / 5) + 2).SetValue("Text to adjust - " + co).Style.Alignment.TextRotation = co; } + + ws2.Columns().AdjustToContents(); + + var ws4 = wb.Worksheets.Add("Adjust Widths 2"); + ws4.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; + for (var co = 0; co < 90; co += 5) + { + var c = ws4.Cell(1, (co / 5) + 2); + + c.GetRichText().AddText("Text to adjust - " + co).SetBold(); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("World!").SetBold().SetFontColor(XLColor.Blue).SetFontSize(25); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("Hello Cruel and unsusual world").SetBold().SetFontSize(20); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("Hello").SetBold(); + c.Style.Alignment.SetTextRotation(co); + } + ws4.Columns().AdjustToContents(); + + var ws3 = wb.Worksheets.Add("Adjust Heights"); + ws3.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; + for (var ro = 0; ro < 90; ro += 5) + { + ws3.Cell((ro / 5) + 2, 1).SetValue("Text to adjust - " + ro).Style.Alignment.TextRotation = ro; + } + + ws3.Rows().AdjustToContents(); + + var ws5 = wb.Worksheets.Add("Adjust Heights 2"); + ws5.Cell(1, 1).SetValue("Text to adjust - 255").Style.Alignment.TextRotation = 255; + for (var ro = 0; ro < 90; ro += 5) + { + var c = ws5.Cell((ro / 5) + 2, 1); + c.GetRichText().AddText("Text to adjust - " + ro).SetBold(); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("World!").SetBold().SetFontColor(XLColor.Blue).SetFontSize(10); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("Hello Cruel and unsusual world").SetBold().SetFontSize(15); + c.GetRichText().AddText(XLConstants.NewLine); + c.GetRichText().AddText("Hello").SetBold(); + c.Style.Alignment.SetTextRotation(ro); + } + + ws5.Rows().AdjustToContents(); + + var ws6 = wb.Worksheets.Add("Absurdly wide column"); + ws6.Cell("A1").Value = "Some string"; + + // This column's width should be capped at 255 + ws6.Cell("B1").Value = @"Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum."; + + ws6.Columns().AdjustToContents(); + + wb.SaveAs(filePath, true); } } } diff --git a/ClosedXML.Examples/Misc/AdjustToContentsWithAutoFilter.cs b/ClosedXML.Examples/Misc/AdjustToContentsWithAutoFilter.cs index bee4237e7..f8206530f 100644 --- a/ClosedXML.Examples/Misc/AdjustToContentsWithAutoFilter.cs +++ b/ClosedXML.Examples/Misc/AdjustToContentsWithAutoFilter.cs @@ -1,14 +1,13 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { public class AdjustToContentsWithAutoFilter : IXLExample { // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("AutoFilter"); ws.Cell("A1").Value = "AVeryLongColumnHeader"; ws.Cell("A2").Value = "John"; @@ -22,4 +21,4 @@ public void Create(String filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/AutoFilter.cs b/ClosedXML.Examples/Misc/AutoFilter.cs index d89e19912..bf5a78012 100644 --- a/ClosedXML.Examples/Misc/AutoFilter.cs +++ b/ClosedXML.Examples/Misc/AutoFilter.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class AutoFilter : IXLExample @@ -12,8 +10,7 @@ public class AutoFilter : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class AutoFilter : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class AutoFilter : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("AutoFilter"); ws.Cell("A1").Value = "Names"; ws.Cell("A2").Value = "John"; @@ -63,7 +58,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/BlankCells.cs b/ClosedXML.Examples/Misc/BlankCells.cs index 20e93fd0e..0e7aee625 100644 --- a/ClosedXML.Examples/Misc/BlankCells.cs +++ b/ClosedXML.Examples/Misc/BlankCells.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class BlankCells : IXLExample @@ -12,8 +10,7 @@ public class BlankCells : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class BlankCells : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class BlankCells : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).Value = "X"; ws.Cell(1, 1).Clear(); @@ -53,7 +48,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/CellValues.cs b/ClosedXML.Examples/Misc/CellValues.cs index b87bb466b..c767c2271 100644 --- a/ClosedXML.Examples/Misc/CellValues.cs +++ b/ClosedXML.Examples/Misc/CellValues.cs @@ -5,144 +5,142 @@ namespace ClosedXML.Examples.Misc { public class CellValues : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - using (var workbook = new XLWorkbook()) - { - var ws = workbook.Worksheets.Add("Cell Values"); - - // Set the titles - ws.Cell(2, 2).Value = "Initial Value"; - ws.Cell(2, 3).Value = "Casting"; - ws.Cell(2, 4).Value = "Using Get...()"; - ws.Cell(2, 5).Value = "Using GetValue()"; - ws.Cell(2, 6).Value = "GetString()"; - ws.Cell(2, 7).Value = "GetFormattedString()"; - - ////////////////////////////////////////////////////////////////// - // DateTime - - // Fill a cell with a date - var cellDateTime = ws.Cell(3, 2); - cellDateTime.Value = new DateTime(2010, 9, 2); - cellDateTime.Style.DateFormat.Format = "yyyy-MMM-dd"; - - // Extract the date in different ways - DateTime dateTime1 = (DateTime)cellDateTime.Value; - DateTime dateTime2 = cellDateTime.GetDateTime(); - DateTime dateTime3 = cellDateTime.GetValue(); - String dateTimeString = cellDateTime.GetString(); - String dateTimeFormattedString = cellDateTime.GetFormattedString(); - - // Set the values back to cells - // The apostrophe is to force ClosedXML to treat the date as a string - ws.Cell(3, 3).Value = dateTime1; - ws.Cell(3, 4).Value = dateTime2; - ws.Cell(3, 5).Value = dateTime3; - ws.Cell(3, 6).Value = "'" + dateTimeString; - ws.Cell(3, 7).Value = "'" + dateTimeFormattedString; - - ////////////////////////////////////////////////////////////////// - // Boolean - - // Fill a cell with a boolean - var cellBoolean = ws.Cell(4, 2); - cellBoolean.Value = true; - - // Extract the boolean in different ways - Boolean boolean1 = (Boolean)cellBoolean.Value; - Boolean boolean2 = cellBoolean.GetBoolean(); - Boolean boolean3 = cellBoolean.GetValue(); - String booleanString = cellBoolean.GetString(); - String booleanFormattedString = cellBoolean.GetFormattedString(); - - // Set the values back to cells - // The apostrophe is to force ClosedXML to treat the boolean as a string - ws.Cell(4, 3).Value = boolean1; - ws.Cell(4, 4).Value = boolean2; - ws.Cell(4, 5).Value = boolean3; - ws.Cell(4, 6).Value = "'" + booleanString; - ws.Cell(4, 7).Value = "'" + booleanFormattedString; - - ////////////////////////////////////////////////////////////////// - // Double - - // Fill a cell with a double - var cellDouble = ws.Cell(5, 2); - cellDouble.Value = 1234.567; - cellDouble.Style.NumberFormat.Format = "#,##0.00"; - - // Extract the double in different ways - Double double1 = (Double)cellDouble.Value; - Double double2 = cellDouble.GetDouble(); - Double double3 = cellDouble.GetValue(); - String doubleString = cellDouble.GetString(); - String doubleFormattedString = cellDouble.GetFormattedString(); - - // Set the values back to cells - // The apostrophe is to force ClosedXML to treat the double as a string - ws.Cell(5, 3).Value = double1; - ws.Cell(5, 4).Value = double2; - ws.Cell(5, 5).Value = double3; - ws.Cell(5, 6).Value = "'" + doubleString; - ws.Cell(5, 7).Value = "'" + doubleFormattedString; - - ////////////////////////////////////////////////////////////////// - // String - - // Fill a cell with a string - var cellString = ws.Cell(6, 2); - cellString.Value = "Test Case"; - - // Extract the string in different ways - String string1 = (String)cellString.Value; - String string2 = cellString.GetString(); - String string3 = cellString.GetValue(); - String stringString = cellString.GetString(); - String stringFormattedString = cellString.GetFormattedString(); - - // Set the values back to cells - ws.Cell(6, 3).Value = string1; - ws.Cell(6, 4).Value = string2; - ws.Cell(6, 5).Value = string3; - ws.Cell(6, 6).Value = stringString; - ws.Cell(6, 7).Value = stringFormattedString; - - ////////////////////////////////////////////////////////////////// - // TimeSpan - - // Fill a cell with a timeSpan - var cellTimeSpan = ws.Cell(7, 2); - cellTimeSpan.Value = new TimeSpan(1, 2, 31, 45); - - // Extract the timeSpan in different ways - TimeSpan timeSpan1 = (TimeSpan)cellTimeSpan.Value; - TimeSpan timeSpan2 = cellTimeSpan.GetTimeSpan(); - TimeSpan timeSpan3 = cellTimeSpan.GetValue(); - String timeSpanString = "'" + cellTimeSpan.GetString(); - String timeSpanFormattedString = "'" + cellTimeSpan.GetFormattedString(); - - // Set the values back to cells - ws.Cell(7, 3).Value = timeSpan1; - ws.Cell(7, 4).Value = timeSpan2; - ws.Cell(7, 5).Value = timeSpan3; - ws.Cell(7, 6).Value = timeSpanString; - ws.Cell(7, 7).Value = timeSpanFormattedString; - - ////////////////////////////////////////////////////////////////// - // Do some formatting - ws.Columns("B:G").Width = 20; - var rngTitle = ws.Range("B2:G2"); - rngTitle.Style.Font.Bold = true; - rngTitle.Style.Fill.BackgroundColor = XLColor.Cyan; - - ws.Columns().AdjustToContents(); - - ws = workbook.AddWorksheet("Test Whitespace"); - ws.FirstCell().Value = "' "; - - workbook.SaveAs(filePath); - } + using var workbook = new XLWorkbook(); + var ws = workbook.Worksheets.Add("Cell Values"); + + // Set the titles + ws.Cell(2, 2).Value = "Initial Value"; + ws.Cell(2, 3).Value = "Casting"; + ws.Cell(2, 4).Value = "Using Get...()"; + ws.Cell(2, 5).Value = "Using GetValue()"; + ws.Cell(2, 6).Value = "GetString()"; + ws.Cell(2, 7).Value = "GetFormattedString()"; + + ////////////////////////////////////////////////////////////////// + // DateTime + + // Fill a cell with a date + var cellDateTime = ws.Cell(3, 2); + cellDateTime.Value = new DateTime(2010, 9, 2); + cellDateTime.Style.DateFormat.Format = "yyyy-MMM-dd"; + + // Extract the date in different ways + var dateTime1 = (DateTime)cellDateTime.Value; + var dateTime2 = cellDateTime.GetDateTime(); + var dateTime3 = cellDateTime.GetValue(); + var dateTimeString = cellDateTime.GetString(); + var dateTimeFormattedString = cellDateTime.GetFormattedString(); + + // Set the values back to cells + // The apostrophe is to force ClosedXML to treat the date as a string + ws.Cell(3, 3).Value = dateTime1; + ws.Cell(3, 4).Value = dateTime2; + ws.Cell(3, 5).Value = dateTime3; + ws.Cell(3, 6).Value = "'" + dateTimeString; + ws.Cell(3, 7).Value = "'" + dateTimeFormattedString; + + ////////////////////////////////////////////////////////////////// + // Boolean + + // Fill a cell with a boolean + var cellBoolean = ws.Cell(4, 2); + cellBoolean.Value = true; + + // Extract the boolean in different ways + var boolean1 = (bool)cellBoolean.Value; + var boolean2 = cellBoolean.GetBoolean(); + var boolean3 = cellBoolean.GetValue(); + var booleanString = cellBoolean.GetString(); + var booleanFormattedString = cellBoolean.GetFormattedString(); + + // Set the values back to cells + // The apostrophe is to force ClosedXML to treat the boolean as a string + ws.Cell(4, 3).Value = boolean1; + ws.Cell(4, 4).Value = boolean2; + ws.Cell(4, 5).Value = boolean3; + ws.Cell(4, 6).Value = "'" + booleanString; + ws.Cell(4, 7).Value = "'" + booleanFormattedString; + + ////////////////////////////////////////////////////////////////// + // Double + + // Fill a cell with a double + var cellDouble = ws.Cell(5, 2); + cellDouble.Value = 1234.567; + cellDouble.Style.NumberFormat.Format = "#,##0.00"; + + // Extract the double in different ways + var double1 = (double)cellDouble.Value; + var double2 = cellDouble.GetDouble(); + var double3 = cellDouble.GetValue(); + var doubleString = cellDouble.GetString(); + var doubleFormattedString = cellDouble.GetFormattedString(); + + // Set the values back to cells + // The apostrophe is to force ClosedXML to treat the double as a string + ws.Cell(5, 3).Value = double1; + ws.Cell(5, 4).Value = double2; + ws.Cell(5, 5).Value = double3; + ws.Cell(5, 6).Value = "'" + doubleString; + ws.Cell(5, 7).Value = "'" + doubleFormattedString; + + ////////////////////////////////////////////////////////////////// + // String + + // Fill a cell with a string + var cellString = ws.Cell(6, 2); + cellString.Value = "Test Case"; + + // Extract the string in different ways + var string1 = (string)cellString.Value; + var string2 = cellString.GetString(); + var string3 = cellString.GetValue(); + var stringString = cellString.GetString(); + var stringFormattedString = cellString.GetFormattedString(); + + // Set the values back to cells + ws.Cell(6, 3).Value = string1; + ws.Cell(6, 4).Value = string2; + ws.Cell(6, 5).Value = string3; + ws.Cell(6, 6).Value = stringString; + ws.Cell(6, 7).Value = stringFormattedString; + + ////////////////////////////////////////////////////////////////// + // TimeSpan + + // Fill a cell with a timeSpan + var cellTimeSpan = ws.Cell(7, 2); + cellTimeSpan.Value = new TimeSpan(1, 2, 31, 45); + + // Extract the timeSpan in different ways + var timeSpan1 = (TimeSpan)cellTimeSpan.Value; + var timeSpan2 = cellTimeSpan.GetTimeSpan(); + var timeSpan3 = cellTimeSpan.GetValue(); + var timeSpanString = "'" + cellTimeSpan.GetString(); + var timeSpanFormattedString = "'" + cellTimeSpan.GetFormattedString(); + + // Set the values back to cells + ws.Cell(7, 3).Value = timeSpan1; + ws.Cell(7, 4).Value = timeSpan2; + ws.Cell(7, 5).Value = timeSpan3; + ws.Cell(7, 6).Value = timeSpanString; + ws.Cell(7, 7).Value = timeSpanFormattedString; + + ////////////////////////////////////////////////////////////////// + // Do some formatting + ws.Columns("B:G").Width = 20; + var rngTitle = ws.Range("B2:G2"); + rngTitle.Style.Font.Bold = true; + rngTitle.Style.Fill.BackgroundColor = XLColor.Cyan; + + ws.Columns().AdjustToContents(); + + ws = workbook.AddWorksheet("Test Whitespace"); + ws.FirstCell().Value = "' "; + + workbook.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/Misc/Collections.cs b/ClosedXML.Examples/Misc/Collections.cs index 26445830b..e4839f96d 100644 --- a/ClosedXML.Examples/Misc/Collections.cs +++ b/ClosedXML.Examples/Misc/Collections.cs @@ -1,8 +1,8 @@ +using ClosedXML.Excel; using System; using System.Collections.Generic; using System.Data; using System.Linq; -using ClosedXML.Excel; namespace ClosedXML.Examples.Misc { @@ -14,8 +14,7 @@ public class Collections : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -25,8 +24,7 @@ public class Collections : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -36,30 +34,33 @@ public class Collections : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Collections"); // From a list of strings - var listOfStrings = new List(); - listOfStrings.Add("House"); - listOfStrings.Add("Car"); + var listOfStrings = new List + { + "House", + "Car" + }; ws.Cell(1, 1).Value = "Strings"; ws.Cell(1, 1).AsRange().AddToNamed("Titles"); ws.Cell(2, 1).Value = listOfStrings; // From a list of arrays - var listOfArr = new List(); - listOfArr.Add(new Int32[] { 1, 2, 3 }); - listOfArr.Add(new Int32[] { 1 }); - listOfArr.Add(new Int32[] { 1, 2, 3, 4, 5, 6 }); + var listOfArr = new List + { + new [] { 1, 2, 3 }, + new [] { 1 }, + new [] { 1, 2, 3, 4, 5, 6 } + }; ws.Cell(1, 3).Value = "Arrays"; ws.Range(1, 3, 1, 8).Merge().AddToNamed("Titles"); ws.Cell(2, 3).Value = listOfArr; @@ -71,11 +72,13 @@ public void Create(String filePath) ws.Cell(7, 1).Value = dataTable; // From a query - var list = new List(); - list.Add(new Person() { Name = "John", Age = 30, House = "On Elm St." }); - list.Add(new Person() { Name = "Mary", Age = 15, House = "On Main St." }); - list.Add(new Person() { Name = "Luis", Age = 21, House = "On 23rd St." }); - list.Add(new Person() { Name = "Henry", Age = 45, House = "On 5th Ave." }); + var list = new List + { + new Person { Name = "John", Age = 30, House = "On Elm St." }, + new Person { Name = "Mary", Age = 15, House = "On Main St." }, + new Person { Name = "Luis", Age = 21, House = "On 23rd St." }, + new Person { Name = "Henry", Age = 45, House = "On 5th Ave." } + }; var people = from p in list where p.Age >= 21 @@ -85,7 +88,6 @@ public void Create(String filePath) ws.Range(6, 6, 6, 8).Merge().AddToNamed("Titles"); ws.Cell(7, 6).Value = people; - // Prepare the style for the titles var titlesStyle = wb.Style; titlesStyle.Font.Bold = true; @@ -100,18 +102,17 @@ public void Create(String filePath) wb.SaveAs(filePath); } - class Person + private class Person { - public String House { get; set; } - public String Name { get; set; } - public Int32 Age { get; set; } + public string House { get; set; } + public string Name { get; set; } + public int Age { get; set; } } // Private private DataTable GetTable() { - - DataTable table = new DataTable(); + var table = new DataTable(); table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -126,7 +127,6 @@ private DataTable GetTable() } // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/CopyingRowsAndColumns.cs b/ClosedXML.Examples/Misc/CopyingRowsAndColumns.cs index d6ca74be1..cac990e91 100644 --- a/ClosedXML.Examples/Misc/CopyingRowsAndColumns.cs +++ b/ClosedXML.Examples/Misc/CopyingRowsAndColumns.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class CopyingRowsAndColumns : IXLExample @@ -12,8 +10,7 @@ public class CopyingRowsAndColumns : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class CopyingRowsAndColumns : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class CopyingRowsAndColumns : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var originalSheet = workbook.Worksheets.Add("original"); @@ -85,7 +80,6 @@ public void Create(String filePath) originalSheet.Column("F").AsRange().CopyTo(fromRangeToColumn.Column(4).AsRange()); fromRangeToColumn.Cell(1, 5).SetValue("Range to Cell:").Style.Alignment.SetTopToBottom(); originalSheet.Column("F").AsRange().CopyTo(fromRangeToColumn.Column(6).FirstCell()); - workbook.SaveAs(filePath); } @@ -97,7 +91,7 @@ private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNu destinationRow.Clear(); var originalRow = originalSheet.Row(originalRowNumber); - int columnNumber = originalRow.LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; + var columnNumber = originalRow.LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; var originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber); var destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber); @@ -108,7 +102,6 @@ private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNu // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/CopyingWorksheets.cs b/ClosedXML.Examples/Misc/CopyingWorksheets.cs index 4ff7ad321..2cbffda2a 100644 --- a/ClosedXML.Examples/Misc/CopyingWorksheets.cs +++ b/ClosedXML.Examples/Misc/CopyingWorksheets.cs @@ -1,5 +1,5 @@ -using ClosedXML.Excel; using ClosedXML.Examples.Tables; +using ClosedXML.Excel; using System.IO; namespace ClosedXML.Examples.Misc @@ -8,12 +8,12 @@ public class CopyingWorksheets : IXLExample { public void Create(string filePath) { - string tempFile1 = ExampleHelper.GetTempFilePath(filePath); - string tempFile2 = ExampleHelper.GetTempFilePath(filePath); + var tempFile1 = ExampleHelper.GetTempFilePath(filePath); + var tempFile2 = ExampleHelper.GetTempFilePath(filePath); try { new UsingTables().Create(tempFile1); - var wb = new XLWorkbook(tempFile1); + using var wb = new XLWorkbook(tempFile1); var wsSource = wb.Worksheet(1); // Copy the worksheet to a new sheet in this workbook @@ -22,7 +22,7 @@ public void Create(string filePath) // We're going to open another workbook to show that you can // copy a sheet from one workbook to another: new BasicTable().Create(tempFile2); - var wbSource = new XLWorkbook(tempFile2); + using var wbSource = new XLWorkbook(tempFile2); wbSource.Worksheet(1).CopyTo(wb, "Copy From Other"); // Save the workbook with the 2 copies @@ -41,4 +41,4 @@ public void Create(string filePath) } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataTypes.cs b/ClosedXML.Examples/Misc/DataTypes.cs index 7a6b2d031..f00240612 100644 --- a/ClosedXML.Examples/Misc/DataTypes.cs +++ b/ClosedXML.Examples/Misc/DataTypes.cs @@ -1,6 +1,5 @@ -using System; using ClosedXML.Excel; - +using System; namespace ClosedXML.Examples.Misc { @@ -12,8 +11,7 @@ public class DataTypes : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +21,7 @@ public class DataTypes : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +31,14 @@ public class DataTypes : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Data Types"); var co = 2; @@ -221,7 +217,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataTypesUnderDifferentCulture.cs b/ClosedXML.Examples/Misc/DataTypesUnderDifferentCulture.cs index 9a1c9ac3a..47a7c1b00 100644 --- a/ClosedXML.Examples/Misc/DataTypesUnderDifferentCulture.cs +++ b/ClosedXML.Examples/Misc/DataTypesUnderDifferentCulture.cs @@ -1,8 +1,7 @@ -using System; using ClosedXML.Excel; -using System.Threading; using System.Globalization; using System.IO; +using System.Threading; namespace ClosedXML.Examples.Misc { @@ -15,11 +14,11 @@ public void Create(string filePath) // Set thread culture to French, which should format numbers using decimal COMMA Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR"); - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new DataTypes().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); workbook.SaveAs(filePath); } finally @@ -32,4 +31,4 @@ public void Create(string filePath) } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidation.cs b/ClosedXML.Examples/Misc/DataValidation.cs index 3bb770c83..6c43b5459 100644 --- a/ClosedXML.Examples/Misc/DataValidation.cs +++ b/ClosedXML.Examples/Misc/DataValidation.cs @@ -1,8 +1,5 @@ -using System; using ClosedXML.Excel; -using System.Globalization; -using System.Threading; - +using System; namespace ClosedXML.Examples.Misc { @@ -14,8 +11,7 @@ public class DataValidation : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -25,8 +21,7 @@ public class DataValidation : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -36,15 +31,14 @@ public class DataValidation : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Data Validation"); // Decimal between 1 and 5 @@ -77,7 +71,6 @@ public void Create(String filePath) ws.Range("B1:B4").CreateDataValidation().WholeNumber.EqualTo(1); ws.Range("B3:B4").CreateDataValidation().WholeNumber.EqualTo(2); - // Validate with multiple ranges var ws2 = wb.Worksheets.Add("Validate Ranges"); var rng1 = ws2.Ranges("A1:B2,B4:D7,F4:G5"); @@ -141,7 +134,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidationDate.cs b/ClosedXML.Examples/Misc/DataValidationDate.cs index ef9cb0d57..93b8e4c6b 100644 --- a/ClosedXML.Examples/Misc/DataValidationDate.cs +++ b/ClosedXML.Examples/Misc/DataValidationDate.cs @@ -7,7 +7,7 @@ public class DataValidationDate : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var date1 = new DateTime(2020, 01, 31); var date2 = new DateTime(2020, 02, 29); @@ -37,4 +37,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidationDecimal.cs b/ClosedXML.Examples/Misc/DataValidationDecimal.cs index 6c1c995aa..0cadf5fca 100644 --- a/ClosedXML.Examples/Misc/DataValidationDecimal.cs +++ b/ClosedXML.Examples/Misc/DataValidationDecimal.cs @@ -6,7 +6,7 @@ public class DataValidationDecimal : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var c1 = ws.Cell("A1"); var c2 = ws.Cell("B1"); @@ -36,4 +36,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidationTextLength.cs b/ClosedXML.Examples/Misc/DataValidationTextLength.cs index 910e9fb75..dbd0d1d39 100644 --- a/ClosedXML.Examples/Misc/DataValidationTextLength.cs +++ b/ClosedXML.Examples/Misc/DataValidationTextLength.cs @@ -6,7 +6,7 @@ public class DataValidationTextLength : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var c1 = ws.Cell("A1"); var c2 = ws.Cell("B1"); @@ -34,4 +34,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidationTime.cs b/ClosedXML.Examples/Misc/DataValidationTime.cs index 07cabdc59..3659c09f6 100644 --- a/ClosedXML.Examples/Misc/DataValidationTime.cs +++ b/ClosedXML.Examples/Misc/DataValidationTime.cs @@ -7,7 +7,7 @@ public class DataValidationTime : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var time1 = TimeSpan.FromHours(6); var time2 = TimeSpan.FromHours(12); @@ -37,4 +37,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/DataValidationWholeNumber.cs b/ClosedXML.Examples/Misc/DataValidationWholeNumber.cs index dcee52ed9..d084e838e 100644 --- a/ClosedXML.Examples/Misc/DataValidationWholeNumber.cs +++ b/ClosedXML.Examples/Misc/DataValidationWholeNumber.cs @@ -6,7 +6,7 @@ public class DataValidationWholeNumber : IXLExample { public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var c1 = ws.Cell("A1"); var c2 = ws.Cell("B1"); @@ -34,4 +34,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/Formulas.cs b/ClosedXML.Examples/Misc/Formulas.cs index ca6a2cba4..fea905e69 100644 --- a/ClosedXML.Examples/Misc/Formulas.cs +++ b/ClosedXML.Examples/Misc/Formulas.cs @@ -1,13 +1,12 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { public class Formulas : IXLExample { - public virtual void Create(String filePath) + public virtual void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Formulas"); ws.Cell(1, 1).Value = "Num1"; @@ -76,4 +75,4 @@ public virtual void Create(String filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/FormulasWithEvaluation.cs b/ClosedXML.Examples/Misc/FormulasWithEvaluation.cs index 127c6f47b..4ae52d43d 100644 --- a/ClosedXML.Examples/Misc/FormulasWithEvaluation.cs +++ b/ClosedXML.Examples/Misc/FormulasWithEvaluation.cs @@ -7,10 +7,8 @@ public class FormulasWithEvaluation : Formulas public override void Create(string filePath) { base.Create(filePath); - using (var wb = new XLWorkbook(filePath)) - { - wb.Save(true, true); - } + using var wb = new XLWorkbook(filePath); + wb.Save(true, true); } } } diff --git a/ClosedXML.Examples/Misc/FreezePanes.cs b/ClosedXML.Examples/Misc/FreezePanes.cs index 7ce237824..29555a294 100644 --- a/ClosedXML.Examples/Misc/FreezePanes.cs +++ b/ClosedXML.Examples/Misc/FreezePanes.cs @@ -1,36 +1,33 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { public class FreezePanes : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - // Freeze rows and columns in one shot - var ws1 = wb.AddWorksheet("Freeze1"); - ws1.Cell(5, 5).SetActive(); - ws1.SheetView.Freeze(3, 3); + using var wb = new XLWorkbook(); + // Freeze rows and columns in one shot + var ws1 = wb.AddWorksheet("Freeze1"); + ws1.Cell(5, 5).SetActive(); + ws1.SheetView.Freeze(3, 3); - // You can also be more specific on what you want to freeze - // For example: - var ws2 = wb.AddWorksheet("FreezeRows"); - ws2.Cell(5, 5).SetActive(); - ws2.SheetView.FreezeRows(3); + // You can also be more specific on what you want to freeze + // For example: + var ws2 = wb.AddWorksheet("FreezeRows"); + ws2.Cell(5, 5).SetActive(); + ws2.SheetView.FreezeRows(3); - var ws3 = wb.AddWorksheet("FreezeColumns"); - ws3.Cell(5, 5).SetActive(); - ws3.SheetView.FreezeColumns(3); + var ws3 = wb.AddWorksheet("FreezeColumns"); + ws3.Cell(5, 5).SetActive(); + ws3.SheetView.FreezeColumns(3); - var wsSplit = wb.AddWorksheet("Split View"); - wsSplit.Cell(2, 2).SetActive(); - wsSplit.SheetView.SplitRow = 3; - wsSplit.SheetView.SplitColumn = 3; + var wsSplit = wb.AddWorksheet("Split View"); + wsSplit.Cell(2, 2).SetActive(); + wsSplit.SheetView.SplitRow = 3; + wsSplit.SheetView.SplitColumn = 3; - wb.SaveAs(filePath); - } + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/Misc/HideSheets.cs b/ClosedXML.Examples/Misc/HideSheets.cs index 2a01b7f59..5de8e62c4 100644 --- a/ClosedXML.Examples/Misc/HideSheets.cs +++ b/ClosedXML.Examples/Misc/HideSheets.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class HideSheets : IXLExample @@ -12,8 +10,7 @@ public class HideSheets : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class HideSheets : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,16 +30,15 @@ public class HideSheets : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); - + using var wb = new XLWorkbook(); + wb.Worksheets.Add("First Hidden").Hide(); wb.Worksheets.Add("Visible"); wb.Worksheets.Add("Unhidden").Hide().Unhide(); @@ -57,7 +52,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/HideUnhide.cs b/ClosedXML.Examples/Misc/HideUnhide.cs index 01a2e65e6..423af3f6c 100644 --- a/ClosedXML.Examples/Misc/HideUnhide.cs +++ b/ClosedXML.Examples/Misc/HideUnhide.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class HideUnhide : IXLExample @@ -12,8 +10,7 @@ public class HideUnhide : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class HideUnhide : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class HideUnhide : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Hide Rows Columns"); ws.Columns(1, 3).Hide(); @@ -58,7 +53,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/Hyperlinks.cs b/ClosedXML.Examples/Misc/Hyperlinks.cs index 421d4c361..c66ee4a40 100644 --- a/ClosedXML.Examples/Misc/Hyperlinks.cs +++ b/ClosedXML.Examples/Misc/Hyperlinks.cs @@ -1,6 +1,5 @@ -using System; using ClosedXML.Excel; - +using System; namespace ClosedXML.Examples.Misc { @@ -12,8 +11,7 @@ public class Hyperlinks : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +21,7 @@ public class Hyperlinks : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,23 +31,22 @@ public class Hyperlinks : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Hyperlinks"); wb.Worksheets.Add("Second Sheet"); - Int32 ro = 0; + var ro = 0; // You can create a link with pretty much anything you can put on a // browser: http, ftp, mailto, gopher, news, nntp, etc. - + ws.Cell(++ro, 1).Value = "Link to a web page, no tooltip - Yahoo!"; ws.Cell(ro, 1).SetHyperlink(new XLHyperlink(@"http://www.yahoo.com")); @@ -91,11 +87,11 @@ public void Create(String filePath) ws.Cell(ro, 1).Style.Font.FontColor = XLColor.Red; ws.Cell(ro, 1).Style.Font.Underline = XLFontUnderlineValues.Double; ws.Cell(ro, 1).SetHyperlink(new XLHyperlink(ws.Range("B1:C2"))); - + // Hyperlink via formula - ws.Cell( ++ro, 1 ).SetValue( "Send Email" ) - .SetFormulaA1( "=HYPERLINK(\"mailto:test@test.com\", \"Send Email\")" ) - .SetHyperlink(new XLHyperlink( "mailto:test@test.com", "'Send Email'" )); + ws.Cell(++ro, 1).SetValue("Send Email") + .SetFormulaA1("=HYPERLINK(\"mailto:test@test.com\", \"Send Email\")") + .SetHyperlink(new XLHyperlink("mailto:test@test.com", "'Send Email'")); // List all hyperlinks in a worksheet: var hyperlinksInWorksheet = ws.Hyperlinks; @@ -122,7 +118,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/InsertingData.cs b/ClosedXML.Examples/Misc/InsertingData.cs index 8107a32d1..42bd82597 100644 --- a/ClosedXML.Examples/Misc/InsertingData.cs +++ b/ClosedXML.Examples/Misc/InsertingData.cs @@ -11,85 +11,92 @@ public class InsertingData : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Inserting Data"); + + // From a list of strings + var listOfStrings = new List + { + "House", + "001" + }; + ws.Cell(1, 1).Value = "From Strings"; + ws.Cell(1, 1).AsRange().AddToNamed("Titles"); + ws.Cell(2, 1).InsertData(listOfStrings); + + // From a list of arrays + var listOfArr = new List + { + new []{ 1, 2, 3 }, + new []{ 1 }, + new []{ 1, 2, 3, 4, 5, 6 } + }; + ws.Cell(1, 3).Value = "From Arrays"; + ws.Range(1, 3, 1, 8).Merge().AddToNamed("Titles"); + ws.Cell(2, 3).InsertData(listOfArr); + + // From a DataTable + using var dataTable = GetTable(); + ws.Cell(6, 1).Value = "From DataTable"; + ws.Range(6, 1, 6, 4).Merge().AddToNamed("Titles"); + ws.Cell(7, 1).InsertData(dataTable); + + // From a query + var list = new List { - var ws = wb.Worksheets.Add("Inserting Data"); - - // From a list of strings - var listOfStrings = new List(); - listOfStrings.Add("House"); - listOfStrings.Add("001"); - ws.Cell(1, 1).Value = "From Strings"; - ws.Cell(1, 1).AsRange().AddToNamed("Titles"); - ws.Cell(2, 1).InsertData(listOfStrings); - - // From a list of arrays - var listOfArr = new List(); - listOfArr.Add(new Int32[] { 1, 2, 3 }); - listOfArr.Add(new Int32[] { 1 }); - listOfArr.Add(new Int32[] { 1, 2, 3, 4, 5, 6 }); - ws.Cell(1, 3).Value = "From Arrays"; - ws.Range(1, 3, 1, 8).Merge().AddToNamed("Titles"); - ws.Cell(2, 3).InsertData(listOfArr); - - // From a DataTable - var dataTable = GetTable(); - ws.Cell(6, 1).Value = "From DataTable"; - ws.Range(6, 1, 6, 4).Merge().AddToNamed("Titles"); - ws.Cell(7, 1).InsertData(dataTable); - - // From a query - var list = new List(); - list.Add(new Person() { Name = "John", Age = 30, House = "On Elm St." }); - list.Add(new Person() { Name = "Mary", Age = 15, House = "On Main St." }); - list.Add(new Person() { Name = "Luis", Age = 21, House = "On 23rd St." }); - list.Add(new Person() { Name = "Henry", Age = 45, House = "On 5th Ave." }); - - var people = from p in list - where p.Age >= 21 - select new { p.Name, p.House, p.Age }; - - ws.Cell(6, 6).Value = "From Query"; - ws.Range(6, 6, 6, 8).Merge().AddToNamed("Titles"); - ws.Cell(7, 6).InsertData(people); - - ws.Cell(11, 6).Value = "From List"; - ws.Range(11, 6, 11, 9).Merge().AddToNamed("Titles"); - ws.Cell(12, 6).InsertData(list); - - ws.Cell("A13").Value = "Transposed"; - ws.Range(13, 1, 13, 3).Merge().AddToNamed("Titles"); - ws.Cell("A14").InsertData(people.AsEnumerable(), true); - - // Prepare the style for the titles - var titlesStyle = wb.Style; - titlesStyle.Font.Bold = true; - titlesStyle.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; - titlesStyle.Fill.BackgroundColor = XLColor.Cyan; - - // Format all titles in one shot - wb.NamedRanges.NamedRange("Titles").Ranges.Style = titlesStyle; - - ws.Columns().AdjustToContents(); - - wb.SaveAs(filePath); - } + new Person { Name = "John", Age = 30, House = "On Elm St." }, + new Person { Name = "Mary", Age = 15, House = "On Main St." }, + new Person { Name = "Luis", Age = 21, House = "On 23rd St." }, + new Person { Name = "Henry", Age = 45, House = "On 5th Ave." } + }; + + var people = from p in list + where p.Age >= 21 + select new { p.Name, p.House, p.Age }; + + ws.Cell(6, 6).Value = "From Query"; + ws.Range(6, 6, 6, 8).Merge().AddToNamed("Titles"); + ws.Cell(7, 6).InsertData(people); + + ws.Cell(11, 6).Value = "From List"; + ws.Range(11, 6, 11, 9).Merge().AddToNamed("Titles"); + ws.Cell(12, 6).InsertData(list); + + ws.Cell("A13").Value = "Transposed"; + ws.Range(13, 1, 13, 3).Merge().AddToNamed("Titles"); + ws.Cell("A14").InsertData(people.AsEnumerable(), true); + + // Prepare the style for the titles + var titlesStyle = wb.Style; + titlesStyle.Font.Bold = true; + titlesStyle.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; + titlesStyle.Fill.BackgroundColor = XLColor.Cyan; + + // Format all titles in one shot + wb.NamedRanges.NamedRange("Titles").Ranges.Style = titlesStyle; + + ws.Columns().AdjustToContents(); + + wb.SaveAs(filePath); } private class Person { - public String House { get; set; } - public String Name { get; set; } - public Int32 Age { get; set; } - public static String ClassType { get { return nameof(Person); } } + public string House { get; set; } + public string Name { get; set; } + public int Age { get; set; } + +#pragma warning disable S1144 // Causing failing test if removed + public static string ClassType => nameof(Person); +#pragma warning restore S1144 // Causing failing test if removed } // Private private DataTable GetTable() { - DataTable table = new DataTable(); + var table = new DataTable(); table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -107,4 +114,4 @@ private DataTable GetTable() #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/LambdaExpressions.cs b/ClosedXML.Examples/Misc/LambdaExpressions.cs index 8e81572bd..e84090c57 100644 --- a/ClosedXML.Examples/Misc/LambdaExpressions.cs +++ b/ClosedXML.Examples/Misc/LambdaExpressions.cs @@ -1,7 +1,7 @@ -using System.IO; -using System.Linq; using ClosedXML.Excel; using MoreLinq; +using System.IO; +using System.Linq; namespace ClosedXML.Examples { @@ -9,12 +9,11 @@ public class LambdaExpressions : IXLExample { public void Create(string filePath) { - - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); // Define a range with the data @@ -54,4 +53,4 @@ public void Create(string filePath) } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/MergeCells.cs b/ClosedXML.Examples/Misc/MergeCells.cs index ffc0f6d92..8973fbeca 100644 --- a/ClosedXML.Examples/Misc/MergeCells.cs +++ b/ClosedXML.Examples/Misc/MergeCells.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class MergeCells : IXLExample @@ -12,8 +10,7 @@ public class MergeCells : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,18 +20,15 @@ public class MergeCells : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public - // Private - - #endregion + #endregion Constructors #region Events @@ -44,15 +38,14 @@ public class MergeCells : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Merge Cells"); // Merge a row @@ -82,7 +75,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/MergeMoves.cs b/ClosedXML.Examples/Misc/MergeMoves.cs index 60c5110f9..8b554411b 100644 --- a/ClosedXML.Examples/Misc/MergeMoves.cs +++ b/ClosedXML.Examples/Misc/MergeMoves.cs @@ -1,19 +1,17 @@ -using System.IO; using ClosedXML.Excel; - +using System.IO; namespace ClosedXML.Examples.Misc { public class MergeMoves : IXLExample { - public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new MergeCells().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); @@ -48,6 +46,5 @@ public void Create(string filePath) } } } - } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/MultipleSheets.cs b/ClosedXML.Examples/Misc/MultipleSheets.cs index 58e83f356..137c646cd 100644 --- a/ClosedXML.Examples/Misc/MultipleSheets.cs +++ b/ClosedXML.Examples/Misc/MultipleSheets.cs @@ -1,22 +1,20 @@ -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.Misc { public class MultipleSheets : IXLExample { - public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); foreach (var wsNum in Enumerable.Range(1, 5)) { wb.Worksheets.Add("Original Pos. is " + wsNum.ToString()); } // Move first worksheet to the last position - wb.Worksheet(1).Position = wb.Worksheets.Count() + 1; + wb.Worksheet(1).Position = wb.Worksheets.Count + 1; // Delete worksheet on position 4 (in this case it's where original position = 5) wb.Worksheet(4).Delete(); @@ -27,4 +25,4 @@ public void Create(string filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/Outline.cs b/ClosedXML.Examples/Misc/Outline.cs index b981555e9..6070d0d08 100644 --- a/ClosedXML.Examples/Misc/Outline.cs +++ b/ClosedXML.Examples/Misc/Outline.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class Outline : IXLExample @@ -12,8 +10,7 @@ public class Outline : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class Outline : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class Outline : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Outline"); ws.Outline.SummaryHLocation = XLOutlineSummaryHLocation.Right; @@ -80,7 +75,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/RightToLeft.cs b/ClosedXML.Examples/Misc/RightToLeft.cs index 9133074d0..19dd2c643 100644 --- a/ClosedXML.Examples/Misc/RightToLeft.cs +++ b/ClosedXML.Examples/Misc/RightToLeft.cs @@ -1,13 +1,12 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { public class RightToLeft : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("RightToLeftSheet"); ws.Cell("A1").Value = "A1"; @@ -18,4 +17,4 @@ public void Create(String filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/SheetProtection.cs b/ClosedXML.Examples/Misc/SheetProtection.cs index d2794d06a..d72baf85b 100644 --- a/ClosedXML.Examples/Misc/SheetProtection.cs +++ b/ClosedXML.Examples/Misc/SheetProtection.cs @@ -1,14 +1,13 @@ using ClosedXML.Excel; -using System; using static ClosedXML.Excel.XLProtectionAlgorithm; namespace ClosedXML.Examples.Misc { public class SheetProtection : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Protected No-Password"); ws.Protect().AllowElement @@ -55,4 +54,4 @@ public void Create(String filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/SheetViews.cs b/ClosedXML.Examples/Misc/SheetViews.cs index 1cba05cac..1c6d8c647 100644 --- a/ClosedXML.Examples/Misc/SheetViews.cs +++ b/ClosedXML.Examples/Misc/SheetViews.cs @@ -6,39 +6,37 @@ public class SheetViews : IXLExample { public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws; + using var wb = new XLWorkbook(); + IXLWorksheet ws; - ws = wb.AddWorksheet("ZoomScale"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScale = 50; + ws = wb.AddWorksheet("ZoomScale"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScale = 50; - ws = wb.AddWorksheet("ZoomScaleNormal"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScaleNormal = 70; + ws = wb.AddWorksheet("ZoomScaleNormal"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScaleNormal = 70; - ws = wb.AddWorksheet("ZoomScalePageLayoutView"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScalePageLayoutView = 85; + ws = wb.AddWorksheet("ZoomScalePageLayoutView"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScalePageLayoutView = 85; - ws = wb.AddWorksheet("ZoomScaleSheetLayoutView"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScaleSheetLayoutView = 120; + ws = wb.AddWorksheet("ZoomScaleSheetLayoutView"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScaleSheetLayoutView = 120; - ws = wb.AddWorksheet("ZoomScaleTooSmall"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScale = 5; + ws = wb.AddWorksheet("ZoomScaleTooSmall"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScale = 5; - ws = wb.AddWorksheet("ZoomScaleTooBig"); - ws.FirstCell().SetValue(ws.Name); - ws.SheetView.ZoomScale = 500; + ws = wb.AddWorksheet("ZoomScaleTooBig"); + ws.FirstCell().SetValue(ws.Name); + ws.SheetView.ZoomScale = 500; - ws = wb.AddWorksheet("TopLeftCell"); - ws.SheetView.TopLeftCellAddress = ws.Cell("AZ2000").Address; + ws = wb.AddWorksheet("TopLeftCell"); + ws.SheetView.TopLeftCellAddress = ws.Cell("AZ2000").Address; - wb.SaveAs(filePath); - } + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/Misc/ShiftingFormulas.cs b/ClosedXML.Examples/Misc/ShiftingFormulas.cs index 8d2930730..b7ec7e674 100644 --- a/ClosedXML.Examples/Misc/ShiftingFormulas.cs +++ b/ClosedXML.Examples/Misc/ShiftingFormulas.cs @@ -1,7 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.Misc { @@ -13,8 +11,7 @@ public class ShiftingFormulas : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -24,8 +21,7 @@ public class ShiftingFormulas : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -35,15 +31,14 @@ public class ShiftingFormulas : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Shifting Formulas"); ws.Cell("B2").Value = 5; ws.Cell("B3").Value = 6; @@ -76,7 +71,7 @@ public void Create(String filePath) ws.Row(1).InsertRowsAbove(1); var newRow = dataGrid.LastRow().InsertRowsAbove(1).First(); newRow.Value = 1; - dataGrid.LastColumn().FormulaR1C1 = String.Format("SUM(RC[-{0}]:RC[-1])", dataGrid.ColumnCount() - 1); + dataGrid.LastColumn().FormulaR1C1 = string.Format("SUM(RC[-{0}]:RC[-1])", dataGrid.ColumnCount() - 1); ws.Cell(1, 1).InsertCellsBelow(1); ws.Column(1).InsertColumnsBefore(1); ws.Row(4).Delete(); @@ -87,7 +82,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/ShowCase.cs b/ClosedXML.Examples/Misc/ShowCase.cs index 11c5307d9..9cdc2d04d 100644 --- a/ClosedXML.Examples/Misc/ShowCase.cs +++ b/ClosedXML.Examples/Misc/ShowCase.cs @@ -5,10 +5,10 @@ namespace ClosedXML.Examples { public class ShowCase : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { // Creating a new workbook - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); //Adding a worksheet var ws = wb.Worksheets.Add("Contacts"); @@ -101,4 +101,4 @@ public void Create(String filePath) wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/TabColors.cs b/ClosedXML.Examples/Misc/TabColors.cs index 6de120b84..3bbfbf750 100644 --- a/ClosedXML.Examples/Misc/TabColors.cs +++ b/ClosedXML.Examples/Misc/TabColors.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { public class TabColors : IXLExample @@ -12,8 +10,7 @@ public class TabColors : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class TabColors : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class TabColors : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var wsRed = wb.Worksheets.Add("Red").SetTabColor(XLColor.Red); @@ -61,7 +56,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/WorkbookProperties.cs b/ClosedXML.Examples/Misc/WorkbookProperties.cs index 847ca66b3..43ddf6ce1 100644 --- a/ClosedXML.Examples/Misc/WorkbookProperties.cs +++ b/ClosedXML.Examples/Misc/WorkbookProperties.cs @@ -1,6 +1,5 @@ -using System; using ClosedXML.Excel; - +using System; namespace ClosedXML.Examples.Misc { @@ -12,8 +11,7 @@ public class WorkbookProperties : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +21,7 @@ public class WorkbookProperties : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +31,14 @@ public class WorkbookProperties : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Workbook Properties"); wb.Properties.Author = "theAuthor"; @@ -69,7 +65,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Misc/WorkbookProtection.cs b/ClosedXML.Examples/Misc/WorkbookProtection.cs index 9d2d92bce..7f6aed11c 100644 --- a/ClosedXML.Examples/Misc/WorkbookProtection.cs +++ b/ClosedXML.Examples/Misc/WorkbookProtection.cs @@ -1,5 +1,4 @@ -using System; -using ClosedXML.Excel; +using ClosedXML.Excel; namespace ClosedXML.Examples.Misc { @@ -8,16 +7,16 @@ public class WorkbookProtection : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Workbook Protection"); - wb.Protect(true, false, "Abc@123"); - wb.SaveAs(filePath); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Workbook Protection"); +#pragma warning disable CS0618 // Type or member is obsolete, but still should be tested + wb.Protect(true, false, "Abc@123"); +#pragma warning restore CS0618 // Type or member is obsolete, but still should be tested + wb.SaveAs(filePath); } - #endregion + #endregion Methods } } diff --git a/ClosedXML.Examples/PageSetup/HeaderFooters.cs b/ClosedXML.Examples/PageSetup/HeaderFooters.cs index a63663e0c..cf3503ff9 100644 --- a/ClosedXML.Examples/PageSetup/HeaderFooters.cs +++ b/ClosedXML.Examples/PageSetup/HeaderFooters.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.PageSetup { public class HeaderFooters : IXLExample @@ -9,17 +7,17 @@ public class HeaderFooters : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Headers and Footers"); - + // Simple left header to be placed on all pages ws.PageSetup.Header.Left.AddText("Created with ClosedXML"); // Using various font decorations for the right header on the first page only // Here we show different methods for setting font decorations. - + // Set single font decorations immediately ws.PageSetup.Header.Right.AddText("The ", XLHFOccurrence.FirstPage).SetBold(); ws.PageSetup.Header.Right.AddText("First ", XLHFOccurrence.FirstPage).SetFontColor(XLColor.Red); @@ -35,7 +33,6 @@ public void Create(String filePath) .SetItalic() .SetFontName("Broadway"); - // Using predefined header/footer text: // Let's put the full path to the file on the right footer of every odd page: @@ -59,7 +56,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PageSetup/Margins.cs b/ClosedXML.Examples/PageSetup/Margins.cs index 3a01c4b79..2cf9fbbc5 100644 --- a/ClosedXML.Examples/PageSetup/Margins.cs +++ b/ClosedXML.Examples/PageSetup/Margins.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.PageSetup { public class Margins : IXLExample @@ -9,9 +7,9 @@ public class Margins : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Margins"); ws.PageSetup.Margins.Top = 1; ws.PageSetup.Margins.Bottom = 1.25; @@ -30,7 +28,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PageSetup/Page.cs b/ClosedXML.Examples/PageSetup/Page.cs index 42ae061ea..21386119b 100644 --- a/ClosedXML.Examples/PageSetup/Page.cs +++ b/ClosedXML.Examples/PageSetup/Page.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.PageSetup { public class Page : IXLExample @@ -9,9 +7,9 @@ public class Page : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws1 = workbook.Worksheets.Add("Page Setup - Page1"); ws1.PageSetup.PageOrientation = XLPageOrientation.Landscape; ws1.PageSetup.AdjustTo(80); @@ -37,7 +35,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PageSetup/SheetTab.cs b/ClosedXML.Examples/PageSetup/SheetTab.cs index c88956425..d1df416c6 100644 --- a/ClosedXML.Examples/PageSetup/SheetTab.cs +++ b/ClosedXML.Examples/PageSetup/SheetTab.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.PageSetup { public class SheetTab : IXLExample @@ -9,17 +7,17 @@ public class SheetTab : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Sheet Tab"); - + // Adding print areas ws.PageSetup.PrintAreas.Add("A1:B2"); ws.PageSetup.PrintAreas.Add("D3:D5"); // Adding rows to repeat at top - ws.PageSetup.SetRowsToRepeatAtTop(1,2); + ws.PageSetup.SetRowsToRepeatAtTop(1, 2); // Adding columns to repeat at left ws.PageSetup.SetColumnsToRepeatAtLeft(1, 2); @@ -44,7 +42,7 @@ public void Create(String filePath) // Print errors as #N/A ws.PageSetup.PrintErrorValue = XLPrintErrorValues.NA; - + workbook.SaveAs(filePath); } @@ -52,7 +50,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PageSetup/Sheets.cs b/ClosedXML.Examples/PageSetup/Sheets.cs index fc19d690b..1c69d75ba 100644 --- a/ClosedXML.Examples/PageSetup/Sheets.cs +++ b/ClosedXML.Examples/PageSetup/Sheets.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.PageSetup { public class Sheets : IXLExample @@ -9,9 +7,9 @@ public class Sheets : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws1 = workbook.Worksheets.Add("Separate PrintAreas"); ws1.PageSetup.PrintAreas.Add("A1:B2"); ws1.PageSetup.PrintAreas.Add("D3:D5"); @@ -20,7 +18,7 @@ public void Create(String filePath) ws2.PageSetup.PrintAreas.Add("A1:D5"); ws2.PageSetup.AddHorizontalPageBreak(2); ws2.PageSetup.AddVerticalPageBreak(2); - + workbook.SaveAs(filePath); } @@ -28,7 +26,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PageSetup/TwoPages.cs b/ClosedXML.Examples/PageSetup/TwoPages.cs index 2e8ac29da..b943a0f0a 100644 --- a/ClosedXML.Examples/PageSetup/TwoPages.cs +++ b/ClosedXML.Examples/PageSetup/TwoPages.cs @@ -1,7 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.PageSetup { @@ -10,9 +8,9 @@ public class TwoPages : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); foreach (var ro in Enumerable.Range(1, 100)) { @@ -30,7 +28,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/PivotTables/PivotTables.cs b/ClosedXML.Examples/PivotTables/PivotTables.cs index be2ce66d5..9c666d80f 100644 --- a/ClosedXML.Examples/PivotTables/PivotTables.cs +++ b/ClosedXML.Examples/PivotTables/PivotTables.cs @@ -26,7 +26,7 @@ public Pastry(string name, int? code, int numberOfOrders, double quality, string public DateTime? BakeDate { get; set; } } - public void Create(String filePath) + public void Create(string filePath) { var pastries = new List { @@ -52,183 +52,188 @@ public void Create(String filePath) new Pastry("Scone", null, 255, 18.4, null, null), }; - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("PastrySalesData"); + // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 + var table = ws.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); + ws.Columns().AdjustToContents(); + + + IXLWorksheet ptSheet; + IXLPivotTable pt; + + #region Pivots + + for (var i = 1; i <= 3; i++) { - var ws = wb.Worksheets.Add("PastrySalesData"); - // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 - var table = ws.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); - ws.Columns().AdjustToContents(); + // Add a new sheet for our pivot table + ptSheet = wb.Worksheets.Add("pvt" + i); + // Create the pivot table, using the data from the "PastrySalesData" table + pt = ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table.AsRange()); - IXLWorksheet ptSheet; - IXLPivotTable pt; + // The rows in our pivot table will be the names of the pastries + if (i == 2) + { + pt.RowLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); + } - #region Pivots + pt.RowLabels.Add("Name"); - for (int i = 1; i <= 3; i++) + // The columns will be the months + pt.ColumnLabels.Add("Month"); + if (i == 3) { - // Add a new sheet for our pivot table - ptSheet = wb.Worksheets.Add("pvt" + i); - - // Create the pivot table, using the data from the "PastrySalesData" table - pt = ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table.AsRange()); - - // The rows in our pivot table will be the names of the pastries - if (i == 2) pt.RowLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); - pt.RowLabels.Add("Name"); - - // The columns will be the months - pt.ColumnLabels.Add("Month"); - if (i == 3) pt.ColumnLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); - - // The values in our table will come from the "NumberOfOrders" field - // The default calculation setting is a total of each row/column - pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") - .ShowAsPercentageFrom("Name").And("Bearclaw") - .NumberFormat.Format = "0%"; - - if (i > 1) - { - pt.Values.Add("Quality", "Sum of Quality") - .NumberFormat.SetFormat("#,##0.00"); - } - if (i > 2) - { - pt.Values.Add("NumberOfOrders", "Sum of NumberOfOrders"); - } - - ptSheet.Columns().AdjustToContents(); + pt.ColumnLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); } - #endregion Pivots + // The values in our table will come from the "NumberOfOrders" field + // The default calculation setting is a total of each row/column + pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") + .ShowAsPercentageFrom("Name").And("Bearclaw") + .NumberFormat.Format = "0%"; - #region Different kind of pivot + if (i > 1) + { + pt.Values.Add("Quality", "Sum of Quality") + .NumberFormat.SetFormat("#,##0.00"); + } + if (i > 2) + { + pt.Values.Add("NumberOfOrders", "Sum of NumberOfOrders"); + } - ptSheet = wb.Worksheets.Add("pvtNoColumnLabels"); - pt = ptSheet.PivotTables.Add("pvtNoColumnLabels", ptSheet.Cell(1, 1), table.AsRange()); + ptSheet.Columns().AdjustToContents(); + } - pt.RowLabels.Add("Name"); - pt.RowLabels.Add("Month"); + #endregion Pivots - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + #region Different kind of pivot - pt.SetRowHeaderCaption("Pastry name"); + ptSheet = wb.Worksheets.Add("pvtNoColumnLabels"); + pt = ptSheet.PivotTables.Add("pvtNoColumnLabels", ptSheet.Cell(1, 1), table.AsRange()); - #endregion Different kind of pivot + pt.RowLabels.Add("Name"); + pt.RowLabels.Add("Month"); - #region Pivot table with collapsed fields + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); - ptSheet = wb.Worksheets.Add("pvtCollapsedFields"); - pt = ptSheet.PivotTables.Add("pvtCollapsedFields", ptSheet.Cell(1, 1), table.AsRange()); + pt.SetRowHeaderCaption("Pastry name"); - pt.RowLabels.Add("Name").SetCollapsed(); - pt.RowLabels.Add("Month").SetCollapsed(); + #endregion Different kind of pivot - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + #region Pivot table with collapsed fields - #endregion Pivot table with collapsed fields + ptSheet = wb.Worksheets.Add("pvtCollapsedFields"); + pt = ptSheet.PivotTables.Add("pvtCollapsedFields", ptSheet.Cell(1, 1), table.AsRange()); - #region Pivot table with a field both as a value and as a row/column/filter label + pt.RowLabels.Add("Name").SetCollapsed(); + pt.RowLabels.Add("Month").SetCollapsed(); - ptSheet = wb.Worksheets.Add("pvtFieldAsValueAndLabel"); - pt = ptSheet.PivotTables.Add("pvtFieldAsValueAndLabel", ptSheet.Cell(1, 1), table.AsRange()); + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); - pt.RowLabels.Add("Name"); - pt.RowLabels.Add("Month"); + #endregion Pivot table with collapsed fields - pt.Values.Add("Name").SetSummaryFormula(XLPivotSummary.Count);//.NumberFormat.Format = "#0.00"; + #region Pivot table with a field both as a value and as a row/column/filter label - #endregion Pivot table with a field both as a value and as a row/column/filter label + ptSheet = wb.Worksheets.Add("pvtFieldAsValueAndLabel"); + pt = ptSheet.PivotTables.Add("pvtFieldAsValueAndLabel", ptSheet.Cell(1, 1), table.AsRange()); - #region Pivot table with subtotals disabled + pt.RowLabels.Add("Name"); + pt.RowLabels.Add("Month"); - ptSheet = wb.Worksheets.Add("pvtHideSubTotals"); + pt.Values.Add("Name").SetSummaryFormula(XLPivotSummary.Count);//.NumberFormat.Format = "#0.00"; - // Create the pivot table, using the data from the "PastrySalesData" table - pt = ptSheet.PivotTables.Add("pvtHidesubTotals", ptSheet.Cell(1, 1), table.AsRange()); + #endregion Pivot table with a field both as a value and as a row/column/filter label - // The rows in our pivot table will be the names of the pastries - pt.RowLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); + #region Pivot table with subtotals disabled - // The columns will be the months - pt.ColumnLabels.Add("Month"); - pt.ColumnLabels.Add("Name"); + ptSheet = wb.Worksheets.Add("pvtHideSubTotals"); - // The values in our table will come from the "NumberOfOrders" field - // The default calculation setting is a total of each row/column - pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") - .ShowAsPercentageFrom("Name").And("Bearclaw") - .NumberFormat.Format = "0%"; + // Create the pivot table, using the data from the "PastrySalesData" table + pt = ptSheet.PivotTables.Add("pvtHidesubTotals", ptSheet.Cell(1, 1), table.AsRange()); - pt.Values.Add("Quality", "Sum of Quality") - .NumberFormat.SetFormat("#,##0.00"); + // The rows in our pivot table will be the names of the pastries + pt.RowLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); - pt.Subtotals = XLPivotSubtotals.DoNotShow; + // The columns will be the months + pt.ColumnLabels.Add("Month"); + pt.ColumnLabels.Add("Name"); - pt.SetColumnHeaderCaption("Measures"); + // The values in our table will come from the "NumberOfOrders" field + // The default calculation setting is a total of each row/column + pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") + .ShowAsPercentageFrom("Name").And("Bearclaw") + .NumberFormat.Format = "0%"; - ptSheet.Columns().AdjustToContents(); + pt.Values.Add("Quality", "Sum of Quality") + .NumberFormat.SetFormat("#,##0.00"); - #endregion Pivot table with subtotals disabled + pt.Subtotals = XLPivotSubtotals.DoNotShow; - #region Pivot Table with filter + pt.SetColumnHeaderCaption("Measures"); - ptSheet = wb.Worksheets.Add("pvtFilter"); + ptSheet.Columns().AdjustToContents(); - pt = table.CreatePivotTable(ptSheet.FirstCell(), "pvtFilter"); + #endregion Pivot table with subtotals disabled - pt.RowLabels.Add("Month"); + #region Pivot Table with filter - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + ptSheet = wb.Worksheets.Add("pvtFilter"); - pt.ReportFilters.Add("Name") - .AddSelectedValue("Scone") - .AddSelectedValue("Doughnut"); + pt = table.CreatePivotTable(ptSheet.FirstCell(), "pvtFilter"); - pt.ReportFilters.Add("Quality") - .AddSelectedValue(5.19); + pt.RowLabels.Add("Month"); - pt.ReportFilters.Add("BakeDate") - .AddSelectedValue(new DateTime(2017, 05, 03)); + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - #endregion Pivot Table with filter - - #region Pivot table sorting + pt.ReportFilters.Add("Name") + .AddSelectedValue("Scone") + .AddSelectedValue("Doughnut"); - ptSheet = wb.Worksheets.Add("pvtSort"); - pt = ptSheet.PivotTables.Add("pvtSort", ptSheet.Cell(1, 1), table.AsRange()); + pt.ReportFilters.Add("Quality") + .AddSelectedValue(5.19); - pt.RowLabels.Add("Name").SetSort(XLPivotSortType.Ascending); - pt.RowLabels.Add("Month").SetSort(XLPivotSortType.Descending); + pt.ReportFilters.Add("BakeDate") + .AddSelectedValue(new DateTime(2017, 05, 03)); - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + #endregion Pivot Table with filter - pt.SetRowHeaderCaption("Pastry name"); + #region Pivot table sorting - #endregion Different kind of pivot + ptSheet = wb.Worksheets.Add("pvtSort"); + pt = ptSheet.PivotTables.Add("pvtSort", ptSheet.Cell(1, 1), table.AsRange()); - #region Pivot Table with integer rows + pt.RowLabels.Add("Name").SetSort(XLPivotSortType.Ascending); + pt.RowLabels.Add("Month").SetSort(XLPivotSortType.Descending); - ptSheet = wb.Worksheets.Add("pvtInteger"); + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); - pt = ptSheet.PivotTables.Add("pvtInteger", ptSheet.Cell(1, 1), table); + pt.SetRowHeaderCaption("Pastry name"); - pt.RowLabels.Add("Name"); - pt.RowLabels.Add("Code"); - pt.RowLabels.Add("BakeDate"); + #endregion Different kind of pivot - pt.ColumnLabels.Add("Month"); + #region Pivot Table with integer rows - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + ptSheet = wb.Worksheets.Add("pvtInteger"); - #endregion Pivot Table with filter + pt = ptSheet.PivotTables.Add("pvtInteger", ptSheet.Cell(1, 1), table); - wb.SaveAs(filePath); - } + pt.RowLabels.Add("Name"); + pt.RowLabels.Add("Code"); + pt.RowLabels.Add("BakeDate"); + + pt.ColumnLabels.Add("Month"); + + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + + #endregion Pivot Table with filter + + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/Program.cs b/ClosedXML.Examples/Program.cs index 253bebc44..754c7ebbf 100644 --- a/ClosedXML.Examples/Program.cs +++ b/ClosedXML.Examples/Program.cs @@ -10,7 +10,11 @@ public static string BaseCreatedDirectory get { var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Created"); - if (!Directory.Exists(path)) Directory.CreateDirectory(path); + if (!Directory.Exists(path)) + { + Directory.CreateDirectory(path); + } + return path; } } @@ -20,7 +24,11 @@ public static string BaseModifiedDirectory get { var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modified"); - if (!Directory.Exists(path)) Directory.CreateDirectory(path); + if (!Directory.Exists(path)) + { + Directory.CreateDirectory(path); + } + return path; } } diff --git a/ClosedXML.Examples/Ranges/AddingRowToTables.cs b/ClosedXML.Examples/Ranges/AddingRowToTables.cs index 539a9665e..a1caf40fa 100644 --- a/ClosedXML.Examples/Ranges/AddingRowToTables.cs +++ b/ClosedXML.Examples/Ranges/AddingRowToTables.cs @@ -1,5 +1,4 @@ using ClosedXML.Excel; -using System; using System.IO; using System.Linq; @@ -10,13 +9,13 @@ public class AddingRowToTables : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var wb = new XLWorkbook(tempFile); + using var wb = new XLWorkbook(tempFile); var ws = wb.Worksheets.First(); var firstCell = ws.FirstCellUsed(); @@ -53,4 +52,4 @@ public void Create(String filePath) #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/ClearingRanges.cs b/ClosedXML.Examples/Ranges/ClearingRanges.cs index 8adb8e62e..5badfbb7a 100644 --- a/ClosedXML.Examples/Ranges/ClearingRanges.cs +++ b/ClosedXML.Examples/Ranges/ClearingRanges.cs @@ -1,7 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.Ranges { @@ -10,9 +8,9 @@ public class ClearingRanges : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Clearing Ranges"); foreach (var ro in Enumerable.Range(1, 10)) { @@ -48,7 +46,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/CopyingRanges.cs b/ClosedXML.Examples/Ranges/CopyingRanges.cs index 7d222224d..b488838f5 100644 --- a/ClosedXML.Examples/Ranges/CopyingRanges.cs +++ b/ClosedXML.Examples/Ranges/CopyingRanges.cs @@ -1,5 +1,5 @@ -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -11,7 +11,7 @@ public void Create(string filePath) try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); // Define a range with the data diff --git a/ClosedXML.Examples/Ranges/CurrentRowColumn.cs b/ClosedXML.Examples/Ranges/CurrentRowColumn.cs index 0dda10784..ad56861ac 100644 --- a/ClosedXML.Examples/Ranges/CurrentRowColumn.cs +++ b/ClosedXML.Examples/Ranges/CurrentRowColumn.cs @@ -1,8 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - namespace ClosedXML.Examples.Ranges { public class CurrentRowColumn : IXLExample @@ -10,9 +7,9 @@ public class CurrentRowColumn : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Current Row Column"); var cell = ws.Cell(5, 2); @@ -45,7 +42,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/DefiningRanges.cs b/ClosedXML.Examples/Ranges/DefiningRanges.cs index ba1af03c7..d60c57044 100644 --- a/ClosedXML.Examples/Ranges/DefiningRanges.cs +++ b/ClosedXML.Examples/Ranges/DefiningRanges.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Ranges { public class DefiningRanges : IXLExample @@ -9,9 +7,9 @@ public class DefiningRanges : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Defining a Range"); // With a string @@ -43,7 +41,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/DeletingRanges.cs b/ClosedXML.Examples/Ranges/DeletingRanges.cs index bb4a41e6a..c943f0293 100644 --- a/ClosedXML.Examples/Ranges/DeletingRanges.cs +++ b/ClosedXML.Examples/Ranges/DeletingRanges.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Ranges { public class DeletingRanges : IXLExample @@ -9,9 +7,9 @@ public class DeletingRanges : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Deleting Ranges"); // Deleting Columns @@ -22,7 +20,7 @@ public void Create(String filePath) ws.Column(7).Delete(); ws.Column(1).Delete(); - ws.Columns(1,2).Delete(); + ws.Columns(1, 2).Delete(); ws.Column(2).Delete(); // Deleting Rows @@ -63,7 +61,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/InsertingDeletingColumns.cs b/ClosedXML.Examples/Ranges/InsertingDeletingColumns.cs index e93b42ba6..9f7401efc 100644 --- a/ClosedXML.Examples/Ranges/InsertingDeletingColumns.cs +++ b/ClosedXML.Examples/Ranges/InsertingDeletingColumns.cs @@ -1,13 +1,12 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples { public class InsertingDeletingColumns : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Inserting and Deleting Columns"); // Range starts with 2 columns @@ -52,4 +51,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/InsertingDeletingRows.cs b/ClosedXML.Examples/Ranges/InsertingDeletingRows.cs index 3d67aadf0..44dfdde1d 100644 --- a/ClosedXML.Examples/Ranges/InsertingDeletingRows.cs +++ b/ClosedXML.Examples/Ranges/InsertingDeletingRows.cs @@ -1,13 +1,12 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples { public class InsertingDeletingRows : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Inserting and Deleting Rows"); // Range starts with 2 rows @@ -52,4 +51,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/MultipleRanges.cs b/ClosedXML.Examples/Ranges/MultipleRanges.cs index 87e32977f..77166124e 100644 --- a/ClosedXML.Examples/Ranges/MultipleRanges.cs +++ b/ClosedXML.Examples/Ranges/MultipleRanges.cs @@ -1,15 +1,14 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples { public class MultipleRanges : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Multiple Ranges"); - + // using multiple string range definitions ws.Ranges("A1:B2,C3:D4,E5:F6").Style.Fill.BackgroundColor = XLColor.Red; @@ -19,4 +18,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/NamedRanges.cs b/ClosedXML.Examples/Ranges/NamedRanges.cs index 06588330f..dee8b2237 100644 --- a/ClosedXML.Examples/Ranges/NamedRanges.cs +++ b/ClosedXML.Examples/Ranges/NamedRanges.cs @@ -1,5 +1,4 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Misc { @@ -8,9 +7,9 @@ public class NamedRanges : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var wsPresentation = wb.Worksheets.Add("Presentation"); var wsData = wb.Worksheets.Add("Data"); @@ -82,4 +81,4 @@ public void Create(String filePath) #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/SelectingRanges.cs b/ClosedXML.Examples/Ranges/SelectingRanges.cs index 4e13ce37f..0c9308da6 100644 --- a/ClosedXML.Examples/Ranges/SelectingRanges.cs +++ b/ClosedXML.Examples/Ranges/SelectingRanges.cs @@ -1,15 +1,12 @@ -using System; -using System.Linq; using ClosedXML.Excel; - namespace ClosedXML.Examples.Ranges { public class SelectingRanges : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var wsActiveCell = wb.AddWorksheet("Set Active Cell"); wsActiveCell.Cell("B2").SetActive(); @@ -24,6 +21,5 @@ public void Create(String filePath) wb.SaveAs(filePath); } - } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/ShiftingRanges.cs b/ClosedXML.Examples/Ranges/ShiftingRanges.cs index 1d8fe5f68..ee32bff8d 100644 --- a/ClosedXML.Examples/Ranges/ShiftingRanges.cs +++ b/ClosedXML.Examples/Ranges/ShiftingRanges.cs @@ -1,5 +1,5 @@ -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -7,11 +7,11 @@ public class ShiftingRanges : IXLExample { public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); // Get a range object @@ -37,4 +37,4 @@ public void Create(string filePath) } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/SortExample.cs b/ClosedXML.Examples/Ranges/SortExample.cs index 875ce3f3a..276ad2aa3 100644 --- a/ClosedXML.Examples/Ranges/SortExample.cs +++ b/ClosedXML.Examples/Ranges/SortExample.cs @@ -1,7 +1,6 @@ +using ClosedXML.Excel; using System; using System.Linq; -using ClosedXML.Excel; - namespace ClosedXML.Examples.Misc { @@ -13,8 +12,7 @@ public class SortExample : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -24,8 +22,7 @@ public class SortExample : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -35,21 +32,21 @@ public class SortExample : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); #region Sort a table + var wsTable = wb.Worksheets.Add("Table"); AddTestTable(wsTable); var header = wsTable.Row(1).InsertRowsAbove(1).First(); - for(Int32 co = 1; co <= wsTable.LastColumnUsed().ColumnNumber(); co++) + for (var co = 1; co <= wsTable.LastColumnUsed().ColumnNumber(); co++) { header.Cell(co).Value = "Column" + co.ToString(); } @@ -57,14 +54,16 @@ public void Create(String filePath) var table = rangeTable.CopyTo(wsTable.Column(wsTable.LastColumnUsed().ColumnNumber() + 3)).CreateTable(); table.Sort("Column2, Column3 Desc, Column1 ASC"); - + wsTable.Row(1).InsertRowsAbove(2); wsTable.Cell(1, 1) .SetValue(".Sort(\"Column2, Column3 Desc, Column1 ASC\") = Sort table Top to Bottom, Col 2 Asc, Col 3 Desc, Col 1 Asc, Ignore Blanks, Ignore Case") .Style.Font.SetBold(); - #endregion + + #endregion Sort a table #region Sort a simple range left to right + var wsLeftToRight = wb.Worksheets.Add("Sort Left to Right"); AddTestTable(wsLeftToRight); wsLeftToRight.RangeUsed().Transpose(XLTransposeOptions.MoveCells); @@ -77,9 +76,11 @@ public void Create(String filePath) wsLeftToRight.Cell(1, 1) .SetValue(".SortLeftToRight() = Sort Range Left to Right, Ascendingly, Ignore Blanks, Ignore Case") .Style.Font.SetBold(); - #endregion + + #endregion Sort a simple range left to right #region Sort a range + var wsComplex2 = wb.Worksheets.Add("Complex 2"); AddTestTable(wsComplex2); var rangeComplex2 = wsComplex2.RangeUsed(); @@ -96,9 +97,11 @@ public void Create(String filePath) .SetValue(".SortColumns.Add(3, XLSortOrder.Descending) = Sort Col 3 Desc, Ignore Blanks, Ignore Case").Style.Font.SetBold(); wsComplex2.Cell(3, 1) .SetValue(".Sort() = Sort range using the parameters defined in SortColumns").Style.Font.SetBold(); - #endregion - #region Sort a range + #endregion Sort a range + + #region Sort a range + var wsComplex1 = wb.Worksheets.Add("Complex 1"); AddTestTable(wsComplex1); var rangeComplex1 = wsComplex1.RangeUsed(); @@ -109,9 +112,11 @@ public void Create(String filePath) wsComplex1.Row(1).InsertRowsAbove(2); wsComplex1.Cell(1, 1) .SetValue(".Sort(\"2, 1 DESC\", XLSortOrder.Ascending, true) = Sort Range Top to Bottom, Col 2 Asc, Col 1 Desc, Ignore Blanks, Match Case").Style.Font.SetBold(); - #endregion + + #endregion Sort a range #region Sort a simple column + var wsSimpleColumn = wb.Worksheets.Add("Simple Column"); AddTestColumn(wsSimpleColumn); var rangeSimpleColumn = wsSimpleColumn.RangeUsed(); @@ -122,19 +127,22 @@ public void Create(String filePath) wsSimpleColumn.Row(1).InsertRowsAbove(2); wsSimpleColumn.Cell(1, 1) .SetValue(".Sort(XLSortOrder.Descending, true) = Sort Range Top to Bottom, Descendingly, Ignore Blanks, Match Case").Style.Font.SetBold(); - #endregion + + #endregion Sort a simple column #region Sort a simple range + var wsSimple = wb.Worksheets.Add("Simple"); AddTestTable(wsSimple); var rangeSimple = wsSimple.RangeUsed(); var copySimple = rangeSimple.CopyTo(wsSimple.Column(wsSimple.LastColumnUsed().ColumnNumber() + 3)); - + copySimple.Sort(); wsSimple.Row(1).InsertRowsAbove(2); wsSimple.Cell(1, 1).SetValue(".Sort() = Sort Range Top to Bottom, Ascendingly, Ignore Blanks, Ignore Case").Style.Font.SetBold(); - #endregion + + #endregion Sort a simple range wb.SaveAs(filePath); } @@ -150,6 +158,7 @@ private void AddTestColumnMixed(IXLWorksheet ws) ws.Cell("A7").SetValue(new TimeSpan(9, 4, 30)).Style.Fill.SetBackgroundColor(XLColor.IndianRed); ws.Cell("A8").SetValue(new DateTime(2011, 4, 15)).Style.Fill.SetBackgroundColor(XLColor.DeepPink); } + private void AddTestColumnNumbers(IXLWorksheet ws) { ws.Cell("A1").SetValue(1.30).Style.Fill.SetBackgroundColor(XLColor.LightGreen); @@ -161,6 +170,7 @@ private void AddTestColumnNumbers(IXLWorksheet ws) ws.Cell("A7").SetValue(4.30).Style.Fill.SetBackgroundColor(XLColor.IndianRed); ws.Cell("A8").SetValue(4.15).Style.Fill.SetBackgroundColor(XLColor.DeepPink); } + private void AddTestColumnTimeSpans(IXLWorksheet ws) { ws.Cell("A1").SetValue(new TimeSpan(0, 12, 35, 21)).Style.Fill.SetBackgroundColor(XLColor.LightGreen); @@ -172,6 +182,7 @@ private void AddTestColumnTimeSpans(IXLWorksheet ws) ws.Cell("A7").SetValue(new TimeSpan(1, 4, 30)).Style.Fill.SetBackgroundColor(XLColor.IndianRed); ws.Cell("A8").SetValue(new TimeSpan(1, 4, 15)).Style.Fill.SetBackgroundColor(XLColor.DeepPink); } + private void AddTestColumnDates(IXLWorksheet ws) { ws.Cell("A1").SetValue(new DateTime(2011, 1, 30)).Style.Fill.SetBackgroundColor(XLColor.LightGreen); @@ -183,6 +194,7 @@ private void AddTestColumnDates(IXLWorksheet ws) ws.Cell("A7").SetValue(new DateTime(2011, 4, 30)).Style.Fill.SetBackgroundColor(XLColor.IndianRed); ws.Cell("A8").SetValue(new DateTime(2011, 4, 15)).Style.Fill.SetBackgroundColor(XLColor.DeepPink); } + private void AddTestColumn(IXLWorksheet ws) { ws.Cell("A1").SetValue("B").Style.Fill.SetBackgroundColor(XLColor.LightGreen); @@ -194,6 +206,7 @@ private void AddTestColumn(IXLWorksheet ws) ws.Cell("A7").SetValue("B").Style.Fill.SetBackgroundColor(XLColor.IndianRed); ws.Cell("A8").SetValue("c").Style.Fill.SetBackgroundColor(XLColor.DeepPink); } + private void AddTestTable(IXLWorksheet ws) { ws.Cell("A1").SetValue("B").Style.Fill.SetBackgroundColor(XLColor.LightGreen); @@ -227,7 +240,6 @@ private void AddTestTable(IXLWorksheet ws) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/Sorting.cs b/ClosedXML.Examples/Ranges/Sorting.cs index 95d6d39a2..6850a6d20 100644 --- a/ClosedXML.Examples/Ranges/Sorting.cs +++ b/ClosedXML.Examples/Ranges/Sorting.cs @@ -5,163 +5,164 @@ namespace ClosedXML.Examples.Misc { public class Sorting : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - - #region Sort Table + using var wb = new XLWorkbook(); - var wsTable = wb.Worksheets.Add("Table"); - AddTestTable(wsTable); + #region Sort Table - wsTable.Row(1).InsertRowsAbove(1); - Int32 lastCo = wsTable.LastColumnUsed().ColumnNumber(); - for (Int32 co = 1; co <= lastCo; co++) - wsTable.Cell(1, co).Value = "Column" + co.ToString(); + var wsTable = wb.Worksheets.Add("Table"); + AddTestTable(wsTable); - var table = wsTable.RangeUsed().AsTable(); - table.Sort("Column2 Desc, 1, 3 Asc"); + wsTable.Row(1).InsertRowsAbove(1); + var lastCo = wsTable.LastColumnUsed().ColumnNumber(); + for (var co = 1; co <= lastCo; co++) + { + wsTable.Cell(1, co).Value = "Column" + co.ToString(); + } - // Sort table another way - wsTable = wb.Worksheets.Add("Table2"); - AddTestTable(wsTable); + var table = wsTable.RangeUsed().AsTable(); + table.Sort("Column2 Desc, 1, 3 Asc"); - wsTable.Row(1).InsertRowsAbove(1); - lastCo = wsTable.LastColumnUsed().ColumnNumber(); - for (Int32 co = 1; co <= lastCo; co++) - wsTable.Cell(1, co).Value = "Column" + co.ToString(); + // Sort table another way + wsTable = wb.Worksheets.Add("Table2"); + AddTestTable(wsTable); - table = wsTable.RangeUsed().AsTable(); - table.Sort("Column2", XLSortOrder.Descending, false, true); + wsTable.Row(1).InsertRowsAbove(1); + lastCo = wsTable.LastColumnUsed().ColumnNumber(); + for (var co = 1; co <= lastCo; co++) + { + wsTable.Cell(1, co).Value = "Column" + co.ToString(); + } + table = wsTable.RangeUsed().AsTable(); + table.Sort("Column2", XLSortOrder.Descending, false, true); - #endregion Sort Table + #endregion Sort Table - #region Sort Rows + #region Sort Rows - var wsRows = wb.Worksheets.Add("Rows"); - AddTestTable(wsRows); - wsRows.Row(1).Sort(); - wsRows.RangeUsed().Row(2).Sort(); - wsRows.Rows(3, wsRows.LastRowUsed().RowNumber()).Delete(); + var wsRows = wb.Worksheets.Add("Rows"); + AddTestTable(wsRows); + wsRows.Row(1).Sort(); + wsRows.RangeUsed().Row(2).Sort(); + wsRows.Rows(3, wsRows.LastRowUsed().RowNumber()).Delete(); - #endregion Sort Rows + #endregion Sort Rows - #region Sort Columns + #region Sort Columns - var wsColumns = wb.Worksheets.Add("Columns"); - AddTestTable(wsColumns); - wsColumns.LastColumnUsed().Delete(); - wsColumns.Column(1).Sort(); - wsColumns.RangeUsed().Column(2).Sort(); + var wsColumns = wb.Worksheets.Add("Columns"); + AddTestTable(wsColumns); + wsColumns.LastColumnUsed().Delete(); + wsColumns.Column(1).Sort(); + wsColumns.RangeUsed().Column(2).Sort(); - #endregion Sort Columns + #endregion Sort Columns - #region Sort Mixed + #region Sort Mixed - var wsMixed = wb.Worksheets.Add("Mixed"); - AddTestColumnMixed(wsMixed); - wsMixed.Sort(); + var wsMixed = wb.Worksheets.Add("Mixed"); + AddTestColumnMixed(wsMixed); + wsMixed.Sort(); - #endregion Sort Mixed + #endregion Sort Mixed - #region Sort Numbers + #region Sort Numbers - var wsNumbers = wb.Worksheets.Add("Numbers"); - AddTestColumnNumbers(wsNumbers); - wsNumbers.Sort(); + var wsNumbers = wb.Worksheets.Add("Numbers"); + AddTestColumnNumbers(wsNumbers); + wsNumbers.Sort(); - #endregion Sort Numbers + #endregion Sort Numbers - #region Sort TimeSpans + #region Sort TimeSpans - var wsTimeSpans = wb.Worksheets.Add("TimeSpans"); - AddTestColumnTimeSpans(wsTimeSpans); - wsTimeSpans.Sort(); + var wsTimeSpans = wb.Worksheets.Add("TimeSpans"); + AddTestColumnTimeSpans(wsTimeSpans); + wsTimeSpans.Sort(); - #endregion Sort TimeSpans + #endregion Sort TimeSpans - #region Sort Dates + #region Sort Dates - var wsDates = wb.Worksheets.Add("Dates"); - AddTestColumnDates(wsDates); - wsDates.Sort(); + var wsDates = wb.Worksheets.Add("Dates"); + AddTestColumnDates(wsDates); + wsDates.Sort(); - #endregion Sort Dates + #endregion Sort Dates - #region Do Not Ignore Blanks + #region Do Not Ignore Blanks - var wsIncludeBlanks = wb.Worksheets.Add("Include Blanks"); - AddTestTable(wsIncludeBlanks); - var rangeIncludeBlanks = wsIncludeBlanks; - rangeIncludeBlanks.SortColumns.Add(1, XLSortOrder.Ascending, false, true); - rangeIncludeBlanks.SortColumns.Add(2, XLSortOrder.Descending, false, true); - rangeIncludeBlanks.Sort(); + var wsIncludeBlanks = wb.Worksheets.Add("Include Blanks"); + AddTestTable(wsIncludeBlanks); + var rangeIncludeBlanks = wsIncludeBlanks; + rangeIncludeBlanks.SortColumns.Add(1, XLSortOrder.Ascending, false, true); + rangeIncludeBlanks.SortColumns.Add(2, XLSortOrder.Descending, false, true); + rangeIncludeBlanks.Sort(); - var wsIncludeBlanksColumn = wb.Worksheets.Add("Include Blanks Column"); - AddTestColumn(wsIncludeBlanksColumn); - var rangeIncludeBlanksColumn = wsIncludeBlanksColumn; - rangeIncludeBlanksColumn.SortColumns.Add(1, XLSortOrder.Ascending, false, true); - rangeIncludeBlanksColumn.Sort(); + var wsIncludeBlanksColumn = wb.Worksheets.Add("Include Blanks Column"); + AddTestColumn(wsIncludeBlanksColumn); + var rangeIncludeBlanksColumn = wsIncludeBlanksColumn; + rangeIncludeBlanksColumn.SortColumns.Add(1, XLSortOrder.Ascending, false, true); + rangeIncludeBlanksColumn.Sort(); - var wsIncludeBlanksColumnDesc = wb.Worksheets.Add("Include Blanks Column Desc"); - AddTestColumn(wsIncludeBlanksColumnDesc); - var rangeIncludeBlanksColumnDesc = wsIncludeBlanksColumnDesc; - rangeIncludeBlanksColumnDesc.SortColumns.Add(1, XLSortOrder.Descending, false, true); - rangeIncludeBlanksColumnDesc.Sort(); + var wsIncludeBlanksColumnDesc = wb.Worksheets.Add("Include Blanks Column Desc"); + AddTestColumn(wsIncludeBlanksColumnDesc); + var rangeIncludeBlanksColumnDesc = wsIncludeBlanksColumnDesc; + rangeIncludeBlanksColumnDesc.SortColumns.Add(1, XLSortOrder.Descending, false, true); + rangeIncludeBlanksColumnDesc.Sort(); - #endregion Do Not Ignore Blanks + #endregion Do Not Ignore Blanks - #region Case Sensitive + #region Case Sensitive - var wsCaseSensitive = wb.Worksheets.Add("Case Sensitive"); - AddTestTable(wsCaseSensitive); - var rangeCaseSensitive = wsCaseSensitive; - rangeCaseSensitive.SortColumns.Add(1, XLSortOrder.Ascending, true, true); - rangeCaseSensitive.SortColumns.Add(2, XLSortOrder.Descending, true, true); - rangeCaseSensitive.Sort(); + var wsCaseSensitive = wb.Worksheets.Add("Case Sensitive"); + AddTestTable(wsCaseSensitive); + var rangeCaseSensitive = wsCaseSensitive; + rangeCaseSensitive.SortColumns.Add(1, XLSortOrder.Ascending, true, true); + rangeCaseSensitive.SortColumns.Add(2, XLSortOrder.Descending, true, true); + rangeCaseSensitive.Sort(); - var wsCaseSensitiveColumn = wb.Worksheets.Add("Case Sensitive Column"); - AddTestColumn(wsCaseSensitiveColumn); - var rangeCaseSensitiveColumn = wsCaseSensitiveColumn; - rangeCaseSensitiveColumn.SortColumns.Add(1, XLSortOrder.Ascending, true, true); - rangeCaseSensitiveColumn.Sort(); + var wsCaseSensitiveColumn = wb.Worksheets.Add("Case Sensitive Column"); + AddTestColumn(wsCaseSensitiveColumn); + var rangeCaseSensitiveColumn = wsCaseSensitiveColumn; + rangeCaseSensitiveColumn.SortColumns.Add(1, XLSortOrder.Ascending, true, true); + rangeCaseSensitiveColumn.Sort(); - var wsCaseSensitiveColumnDesc = wb.Worksheets.Add("Case Sensitive Column Desc"); - AddTestColumn(wsCaseSensitiveColumnDesc); - var rangeCaseSensitiveColumnDesc = wsCaseSensitiveColumnDesc; - rangeCaseSensitiveColumnDesc.SortColumns.Add(1, XLSortOrder.Descending, true, true); - rangeCaseSensitiveColumnDesc.Sort(); + var wsCaseSensitiveColumnDesc = wb.Worksheets.Add("Case Sensitive Column Desc"); + AddTestColumn(wsCaseSensitiveColumnDesc); + var rangeCaseSensitiveColumnDesc = wsCaseSensitiveColumnDesc; + rangeCaseSensitiveColumnDesc.SortColumns.Add(1, XLSortOrder.Descending, true, true); + rangeCaseSensitiveColumnDesc.Sort(); - #endregion Case Sensitive + #endregion Case Sensitive - #region Simple Sorts + #region Simple Sorts - var wsSimple = wb.Worksheets.Add("Simple"); - AddTestTable(wsSimple); - wsSimple.Sort(); + var wsSimple = wb.Worksheets.Add("Simple"); + AddTestTable(wsSimple); + wsSimple.Sort(); - var wsSimpleDesc = wb.Worksheets.Add("Simple Desc"); - AddTestTable(wsSimpleDesc); - wsSimpleDesc.Sort("", XLSortOrder.Descending); + var wsSimpleDesc = wb.Worksheets.Add("Simple Desc"); + AddTestTable(wsSimpleDesc); + wsSimpleDesc.Sort("", XLSortOrder.Descending); - var wsSimpleColumns = wb.Worksheets.Add("Simple Columns"); - AddTestTable(wsSimpleColumns); - wsSimpleColumns.Sort("2, A DESC, 3"); + var wsSimpleColumns = wb.Worksheets.Add("Simple Columns"); + AddTestTable(wsSimpleColumns); + wsSimpleColumns.Sort("2, A DESC, 3"); - var wsSimpleColumn = wb.Worksheets.Add("Simple Column"); - AddTestColumn(wsSimpleColumn); - wsSimpleColumn.Sort(); + var wsSimpleColumn = wb.Worksheets.Add("Simple Column"); + AddTestColumn(wsSimpleColumn); + wsSimpleColumn.Sort(); - var wsSimpleColumnDesc = wb.Worksheets.Add("Simple Column Desc"); - AddTestColumn(wsSimpleColumnDesc); - wsSimpleColumnDesc.Sort(1, XLSortOrder.Descending); + var wsSimpleColumnDesc = wb.Worksheets.Add("Simple Column Desc"); + AddTestColumn(wsSimpleColumnDesc); + wsSimpleColumnDesc.Sort(1, XLSortOrder.Descending); - #endregion Simple Sorts + #endregion Simple Sorts - wb.SaveAs(filePath); - } + wb.SaveAs(filePath); } private void AddTestColumnMixed(IXLWorksheet ws) @@ -254,4 +255,4 @@ private void AddTestTable(IXLWorksheet ws) ws.Cell("C8").SetValue("").Style.Fill.SetBackgroundColor(XLColor.DeepPink); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/TransposeRanges.cs b/ClosedXML.Examples/Ranges/TransposeRanges.cs index 069b7ccd3..0d434adc0 100644 --- a/ClosedXML.Examples/Ranges/TransposeRanges.cs +++ b/ClosedXML.Examples/Ranges/TransposeRanges.cs @@ -1,18 +1,17 @@ -using System.IO; using ClosedXML.Excel; - +using System.IO; namespace ClosedXML.Examples { - public class TransposeRanges:IXLExample + public class TransposeRanges : IXLExample { public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); @@ -31,7 +30,6 @@ public void Create(string filePath) File.Delete(tempFile); } } - } } } \ No newline at end of file diff --git a/ClosedXML.Examples/Ranges/TransposeRangesPlus.cs b/ClosedXML.Examples/Ranges/TransposeRangesPlus.cs index 6846d7398..cb15d36cd 100644 --- a/ClosedXML.Examples/Ranges/TransposeRangesPlus.cs +++ b/ClosedXML.Examples/Ranges/TransposeRangesPlus.cs @@ -1,5 +1,5 @@ -using System.IO; using ClosedXML.Excel; +using System.IO; namespace ClosedXML.Examples { @@ -7,11 +7,11 @@ public class TransposeRangesPlus : IXLExample { public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - var workbook = new XLWorkbook(tempFile); + using var workbook = new XLWorkbook(tempFile); var ws = workbook.Worksheet(1); diff --git a/ClosedXML.Examples/Ranges/WalkingRanges.cs b/ClosedXML.Examples/Ranges/WalkingRanges.cs index 26d374de1..acb24fbfa 100644 --- a/ClosedXML.Examples/Ranges/WalkingRanges.cs +++ b/ClosedXML.Examples/Ranges/WalkingRanges.cs @@ -1,8 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - namespace ClosedXML.Examples.Ranges { public class WalkingRanges : IXLExample @@ -10,9 +7,9 @@ public class WalkingRanges : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Walking Cells"); var cell = ws.Cell(5, 5).SetValue("(5,5)"); @@ -62,7 +59,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Rows/InsertRows.cs b/ClosedXML.Examples/Rows/InsertRows.cs index 772fd1dc1..dabd572ee 100644 --- a/ClosedXML.Examples/Rows/InsertRows.cs +++ b/ClosedXML.Examples/Rows/InsertRows.cs @@ -1,7 +1,5 @@ -using System; -using System.Linq; using ClosedXML.Excel; - +using System.Linq; namespace ClosedXML.Examples.Rows { @@ -13,8 +11,7 @@ public class InsertRows : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -24,8 +21,7 @@ public class InsertRows : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -35,15 +31,14 @@ public class InsertRows : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Inserting Rows"); // Color the entire spreadsheet using rows @@ -51,8 +46,12 @@ public void Create(String filePath) // Put a value in a few cells foreach (var r in Enumerable.Range(1, 5)) + { foreach (var c in Enumerable.Range(1, 5)) + { ws.Cell(r, c).Value = "X"; + } + } var blueRow = ws.Row(2); var redRow = ws.Row(5); @@ -60,7 +59,6 @@ public void Create(String filePath) blueRow.Style.Fill.BackgroundColor = XLColor.Blue; blueRow.InsertRowsBelow(2); - redRow.Style.Fill.BackgroundColor = XLColor.Red; redRow.InsertRowsAbove(2); @@ -77,7 +75,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Rows/RowCells.cs b/ClosedXML.Examples/Rows/RowCells.cs index daddc04eb..4c9fd91b5 100644 --- a/ClosedXML.Examples/Rows/RowCells.cs +++ b/ClosedXML.Examples/Rows/RowCells.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples { public class RowCells : IXLExample @@ -12,8 +10,7 @@ public class RowCells : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,8 +20,7 @@ public class RowCells : IXLExample // Override - - #endregion + #endregion Properties #region Events @@ -34,15 +30,14 @@ public class RowCells : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Row Cells"); var rowFromWorksheet = ws.Row(1); @@ -67,7 +62,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Rows/RowCollection.cs b/ClosedXML.Examples/Rows/RowCollection.cs index 67efa6845..7e7617ee2 100644 --- a/ClosedXML.Examples/Rows/RowCollection.cs +++ b/ClosedXML.Examples/Rows/RowCollection.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Rows { public class RowCollection : IXLExample @@ -12,8 +10,7 @@ public class RowCollection : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,9 +20,7 @@ public class RowCollection : IXLExample // Override - - #endregion - + #endregion Properties #region Events @@ -35,15 +30,14 @@ public class RowCollection : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Rows of a Range"); // All rows in a range @@ -90,7 +84,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Rows/RowSettings.cs b/ClosedXML.Examples/Rows/RowSettings.cs index 24112c733..063d1aa21 100644 --- a/ClosedXML.Examples/Rows/RowSettings.cs +++ b/ClosedXML.Examples/Rows/RowSettings.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Rows { public class RowSettings : IXLExample @@ -12,8 +10,7 @@ public class RowSettings : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,22 +20,18 @@ public class RowSettings : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public public RowSettings() { - } - // Private - - #endregion + #endregion Constructors #region Events @@ -48,15 +41,14 @@ public RowSettings() // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Row Settings"); var row1 = ws.Row(2); @@ -74,7 +66,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Sparklines/SampleSparklines.cs b/ClosedXML.Examples/Sparklines/SampleSparklines.cs index 5b0f65a83..7c1547a31 100644 --- a/ClosedXML.Examples/Sparklines/SampleSparklines.cs +++ b/ClosedXML.Examples/Sparklines/SampleSparklines.cs @@ -7,9 +7,9 @@ namespace ClosedXML.Examples.Sparklines { public class SampleSparklines : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws1 = workbook.AddWorksheet("Linear"); FillSampleData(ws1); @@ -55,7 +55,6 @@ public void Create(String filePath) .SetStyle(XLSparklineTheme.Colorful3) .SetShowMarkers(XLSparklineMarkers.FirstPoint | XLSparklineMarkers.LastPoint); - var ws2 = ws1.CopyTo("Column"); ws2.SparklineGroups.ForEach(g => g.SetType(XLSparklineType.Column)); @@ -67,7 +66,6 @@ public void Create(String filePath) ws2.Cell("A14").Value = "Column, Colorful 4, Line weight=2, Right to left"; ws2.Cell("A17").Value = "Column, Colorful 3, Different ranges"; - var ws3 = ws1.CopyTo("Stacked"); ws3.SparklineGroups.ForEach(g => g.SetType(XLSparklineType.Stacked)); @@ -95,4 +93,4 @@ private void FillSampleData(IXLWorksheet ws) .ForEach(c => c.Value = Math.Round(c.Address.RowNumber * Math.Sin(c.Address.ColumnNumber) * 10, 0)); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/DefaultStyles.cs b/ClosedXML.Examples/Styles/DefaultStyles.cs index 4778e3751..9e382c19f 100644 --- a/ClosedXML.Examples/Styles/DefaultStyles.cs +++ b/ClosedXML.Examples/Styles/DefaultStyles.cs @@ -1,15 +1,13 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Styles { public class DefaultStyles : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { // Create our workbook - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); // This worksheet will have the default style, row height, column width, and page setup var ws1 = workbook.Worksheets.Add("Default Style"); diff --git a/ClosedXML.Examples/Styles/PurpleWorksheet.cs b/ClosedXML.Examples/Styles/PurpleWorksheet.cs index e61a220c1..2efe7ab76 100644 --- a/ClosedXML.Examples/Styles/PurpleWorksheet.cs +++ b/ClosedXML.Examples/Styles/PurpleWorksheet.cs @@ -1,18 +1,16 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Styles { public class PurpleWorksheet : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Purple Worksheet"); ws.Style.Fill.BackgroundColor = XLColor.Purple; - + workbook.SaveAs(filePath); } } diff --git a/ClosedXML.Examples/Styles/StyleAlignment.cs b/ClosedXML.Examples/Styles/StyleAlignment.cs index 8e582e0c8..2418658d2 100644 --- a/ClosedXML.Examples/Styles/StyleAlignment.cs +++ b/ClosedXML.Examples/Styles/StyleAlignment.cs @@ -1,7 +1,5 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Styles { public class StyleAlignment : IXLExample @@ -12,8 +10,7 @@ public class StyleAlignment : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -23,22 +20,18 @@ public class StyleAlignment : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public public StyleAlignment() { - } - // Private - - #endregion + #endregion Constructors #region Events @@ -48,15 +41,14 @@ public StyleAlignment() // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Alignment"); var co = 2; @@ -99,7 +91,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/StyleBorder.cs b/ClosedXML.Examples/Styles/StyleBorder.cs index a925679cb..9902d9ee6 100644 --- a/ClosedXML.Examples/Styles/StyleBorder.cs +++ b/ClosedXML.Examples/Styles/StyleBorder.cs @@ -1,14 +1,12 @@ -using System; - using ClosedXML.Excel; namespace ClosedXML.Examples.Styles { public class StyleBorder : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Border"); var co = 2; diff --git a/ClosedXML.Examples/Styles/StyleFill.cs b/ClosedXML.Examples/Styles/StyleFill.cs index a45acebf7..e4a004b83 100644 --- a/ClosedXML.Examples/Styles/StyleFill.cs +++ b/ClosedXML.Examples/Styles/StyleFill.cs @@ -1,13 +1,12 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Styles { public class StyleFill : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Fill"); var co = 2; @@ -24,4 +23,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/StyleFont.cs b/ClosedXML.Examples/Styles/StyleFont.cs index da9b1e228..2b6906f82 100644 --- a/ClosedXML.Examples/Styles/StyleFont.cs +++ b/ClosedXML.Examples/Styles/StyleFont.cs @@ -1,13 +1,12 @@ using ClosedXML.Excel; -using System; namespace ClosedXML.Examples.Styles { public class StyleFont : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Font"); var co = 2; @@ -50,4 +49,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/StyleIncludeQuotePrefix.cs b/ClosedXML.Examples/Styles/StyleIncludeQuotePrefix.cs index 006d090bb..54abf5380 100644 --- a/ClosedXML.Examples/Styles/StyleIncludeQuotePrefix.cs +++ b/ClosedXML.Examples/Styles/StyleIncludeQuotePrefix.cs @@ -1,14 +1,13 @@ using ClosedXML.Excel; -using System; using System.Linq; namespace ClosedXML.Examples.Styles { public class StyleIncludeQuotePrefix : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style IncludeQuotePrefix"); var data = Enumerable.Range(1, 20) @@ -36,4 +35,4 @@ public void Create(String filePath) workbook.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/StyleNumberFormat.cs b/ClosedXML.Examples/Styles/StyleNumberFormat.cs index 92a1b4999..10797eca2 100644 --- a/ClosedXML.Examples/Styles/StyleNumberFormat.cs +++ b/ClosedXML.Examples/Styles/StyleNumberFormat.cs @@ -1,4 +1,3 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples.Styles @@ -11,8 +10,7 @@ public class StyleNumberFormat : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -22,22 +20,18 @@ public class StyleNumberFormat : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public public StyleNumberFormat() { - } - // Private - - #endregion + #endregion Constructors #region Events @@ -47,15 +41,14 @@ public StyleNumberFormat() // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style NumberFormat"); var co = 2; @@ -79,7 +72,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/StyleRowsColumns.cs b/ClosedXML.Examples/Styles/StyleRowsColumns.cs index 1d893e2a1..5e3ef630f 100644 --- a/ClosedXML.Examples/Styles/StyleRowsColumns.cs +++ b/ClosedXML.Examples/Styles/StyleRowsColumns.cs @@ -1,14 +1,12 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Styles { public class StyleRowsColumns : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Rows and Columns"); //Set the entire worksheet's cells to be bold and with a light cyan background diff --git a/ClosedXML.Examples/Styles/StyleWorksheet.cs b/ClosedXML.Examples/Styles/StyleWorksheet.cs index ca3d8d6c0..152011ca7 100644 --- a/ClosedXML.Examples/Styles/StyleWorksheet.cs +++ b/ClosedXML.Examples/Styles/StyleWorksheet.cs @@ -1,14 +1,12 @@ -using System; using ClosedXML.Excel; - namespace ClosedXML.Examples.Styles { public class StyleWorksheet : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var ws = workbook.Worksheets.Add("Style Worksheet"); ws.Style.Font.Bold = true; diff --git a/ClosedXML.Examples/Styles/UsingColors.cs b/ClosedXML.Examples/Styles/UsingColors.cs index 0ca12bdb0..1644f8144 100644 --- a/ClosedXML.Examples/Styles/UsingColors.cs +++ b/ClosedXML.Examples/Styles/UsingColors.cs @@ -1,18 +1,16 @@ -using System; -using System.Drawing; using ClosedXML.Excel; - +using SkiaSharp; namespace ClosedXML.Examples.Styles { public class UsingColors : IXLExample { - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Using Colors"); - Int32 ro = 0; + var ro = 0; // From Known color ws.Cell(++ro, 1).Style.Fill.BackgroundColor = XLColor.Red; @@ -44,7 +42,7 @@ public void Create(String filePath) ro++; // FromColor(Color color) - ws.Cell(++ro, 1).Style.Fill.BackgroundColor = XLColor.FromColor(Color.Red); + ws.Cell(++ro, 1).Style.Fill.BackgroundColor = XLColor.FromColor(SKColors.Red); ws.Cell(ro, 2).Value = "XLColor.FromColor(Color.Red)"; ro++; @@ -75,10 +73,9 @@ public void Create(String filePath) ws.Cell(++ro, 1).Style.Fill.BackgroundColor = XLColor.FromTheme(XLThemeColor.Accent1, 0.5); ws.Cell(ro, 2).Value = "XLColor.FromTheme(XLThemeColor.Accent1, 0.5)"; - ws.Columns().AdjustToContents(); wb.SaveAs(filePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/UsingPhonetics.cs b/ClosedXML.Examples/Styles/UsingPhonetics.cs index 6b3736438..5def18e39 100644 --- a/ClosedXML.Examples/Styles/UsingPhonetics.cs +++ b/ClosedXML.Examples/Styles/UsingPhonetics.cs @@ -1,18 +1,15 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples.Styles { public class UsingPhonetics : IXLExample { - - #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Using Phonetics"); var cell = ws.Cell(1, 1); @@ -35,7 +32,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Styles/UsingRichText.cs b/ClosedXML.Examples/Styles/UsingRichText.cs index b258bae73..98e1b5e95 100644 --- a/ClosedXML.Examples/Styles/UsingRichText.cs +++ b/ClosedXML.Examples/Styles/UsingRichText.cs @@ -1,4 +1,3 @@ -using System; using ClosedXML.Excel; namespace ClosedXML.Examples.Styles @@ -11,8 +10,7 @@ public class UsingRichText : IXLExample // Private - - #endregion + #endregion Variables #region Properties @@ -22,19 +20,15 @@ public class UsingRichText : IXLExample // Override - - #endregion + #endregion Properties #region Constructors // Public - - // Private - - #endregion + #endregion Constructors #region Events @@ -44,15 +38,14 @@ public class UsingRichText : IXLExample // Override - - #endregion + #endregion Events #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Rich Text"); // Let's start with a plain text and then decorate it... @@ -88,11 +81,12 @@ public void Create(String filePath) // Of course you can loop through each piece of text and check its properties foreach (var richText in cell.GetRichText()) { - if(richText.Bold) - ws.Cell(3, 2).Value = String.Format("\"{0}\" is Bold.", richText.Text); + if (richText.Bold) + { + ws.Cell(3, 2).Value = string.Format("\"{0}\" is Bold.", richText.Text); + } } - // Now we'll build a cell with rich text, and some other styles cell = ws.Cell(5, 1); @@ -105,7 +99,6 @@ public void Create(String filePath) ws.Cell(5, 2).Value = cell.GetRichText(); // Should copy only rich text, but not background - ws.Columns().AdjustToContents(); wb.SaveAs(filePath); @@ -115,7 +108,6 @@ public void Create(String filePath) // Override - - #endregion + #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Tables/InsertingTables.cs b/ClosedXML.Examples/Tables/InsertingTables.cs index 1e749911f..406adce9c 100644 --- a/ClosedXML.Examples/Tables/InsertingTables.cs +++ b/ClosedXML.Examples/Tables/InsertingTables.cs @@ -12,85 +12,89 @@ public class InsertingTables : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Inserting Tables"); + + // From a list of strings + var listOfStrings = new List + { + "House", + "Car" + }; + ws.Cell(1, 1).Value = "From Strings"; + ws.Cell(1, 1).AsRange().AddToNamed("Titles"); + ws.Cell(2, 1).InsertTable(listOfStrings); + + // From a list of arrays + var listOfArr = new List + { + new [] { 1, 2, 3 }, + new [] { 1 }, + new [] { 1, 2, 3, 4, 5, 6 } + }; + ws.Cell(1, 3).Value = "From Arrays"; + ws.Range(1, 3, 1, 8).Merge().AddToNamed("Titles"); + ws.Cell(2, 3).InsertTable(listOfArr); + + // From a DataTable + using var dataTable = GetTable(); + ws.Cell(7, 1).Value = "From DataTable"; + ws.Range(7, 1, 7, 4).Merge().AddToNamed("Titles"); + ws.Cell(8, 1).InsertTable(dataTable); + + // From a query + var list = new List { - var ws = wb.Worksheets.Add("Inserting Tables"); - - // From a list of strings - var listOfStrings = new List(); - listOfStrings.Add("House"); - listOfStrings.Add("Car"); - ws.Cell(1, 1).Value = "From Strings"; - ws.Cell(1, 1).AsRange().AddToNamed("Titles"); - ws.Cell(2, 1).InsertTable(listOfStrings); - - // From a list of arrays - var listOfArr = new List(); - listOfArr.Add(new Int32[] { 1, 2, 3 }); - listOfArr.Add(new Int32[] { 1 }); - listOfArr.Add(new Int32[] { 1, 2, 3, 4, 5, 6 }); - ws.Cell(1, 3).Value = "From Arrays"; - ws.Range(1, 3, 1, 8).Merge().AddToNamed("Titles"); - ws.Cell(2, 3).InsertTable(listOfArr); - - // From a DataTable - var dataTable = GetTable(); - ws.Cell(7, 1).Value = "From DataTable"; - ws.Range(7, 1, 7, 4).Merge().AddToNamed("Titles"); - ws.Cell(8, 1).InsertTable(dataTable); - - // From a query - var list = new List(); - list.Add(new Person() { Name = "John", Age = 30, House = "On Elm St." }); - list.Add(new Person() { Name = "Mary", Age = 15, House = "On Main St." }); - list.Add(new Person() { Name = "Luis", Age = 21, House = "On 23rd St." }); - list.Add(new Person() { Name = "Henry", Age = 45, House = "On 5th Ave." }); - - var people = from p in list - where p.Age >= 21 - select p; - - ws.Cell(7, 6).Value = "From Query"; - ws.Range(7, 6, 7, 9).Merge().AddToNamed("Titles"); - ws.Cell(8, 6).InsertTable(people); - - ws.Cell(15, 6).Value = "From List"; - ws.Range(15, 6, 15, 9).Merge().AddToNamed("Titles"); - ws.Cell(16, 6).InsertTable(people); - - // Prepare the style for the titles - var titlesStyle = wb.Style; - titlesStyle.Font.Bold = true; - titlesStyle.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; - titlesStyle.Fill.BackgroundColor = XLColor.Cyan; - - // Format all titles in one shot - wb.NamedRanges.NamedRange("Titles").Ranges.Style = titlesStyle; - - ws.Columns().AdjustToContents(); - - wb.SaveAs(filePath); - } + new Person { Name = "John", Age = 30, House = "On Elm St." }, + new Person { Name = "Mary", Age = 15, House = "On Main St." }, + new Person { Name = "Luis", Age = 21, House = "On 23rd St." }, + new Person { Name = "Henry", Age = 45, House = "On 5th Ave." } + }; + + var people = from p in list + where p.Age >= 21 + select p; + + ws.Cell(7, 6).Value = "From Query"; + ws.Range(7, 6, 7, 9).Merge().AddToNamed("Titles"); + ws.Cell(8, 6).InsertTable(people); + + ws.Cell(15, 6).Value = "From List"; + ws.Range(15, 6, 15, 9).Merge().AddToNamed("Titles"); + ws.Cell(16, 6).InsertTable(people); + + // Prepare the style for the titles + var titlesStyle = wb.Style; + titlesStyle.Font.Bold = true; + titlesStyle.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; + titlesStyle.Fill.BackgroundColor = XLColor.Cyan; + + // Format all titles in one shot + wb.NamedRanges.NamedRange("Titles").Ranges.Style = titlesStyle; + + ws.Columns().AdjustToContents(); + + wb.SaveAs(filePath); } private class Person { [XLColumn(Header = "House Street")] - public String House { get; set; } + public string House { get; set; } - public String Name { get; set; } - public Int32 Age { get; set; } + public string Name { get; set; } + public int Age { get; set; } [XLColumn(Header = "Class Type")] - public static String ClassType { get { return nameof(Person); } } + public static string ClassType => nameof(Person); } // Private private DataTable GetTable() { - DataTable table = new DataTable(); + var table = new DataTable(); table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -108,4 +112,4 @@ private DataTable GetTable() #endregion Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Examples/Tables/ResizingTables.cs b/ClosedXML.Examples/Tables/ResizingTables.cs index 06ac8112d..5236270d3 100644 --- a/ClosedXML.Examples/Tables/ResizingTables.cs +++ b/ClosedXML.Examples/Tables/ResizingTables.cs @@ -11,43 +11,41 @@ public class ResizingTables : IXLExample { public void Create(string filePath) { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - - var data1 = Enumerable.Range(1, 10) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('a', i), - Integer = 64 + i - }); - - var table1 = ws1.Cell("B2").InsertTable(data1, true) - .SetShowHeaderRow() - .SetShowTotalsRow(); - - table1.Fields.First().TotalsRowLabel = "Sum of Integer"; - table1.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Sum; - - var ws2 = ws1.CopyTo("Sheet2"); - var table2 = ws2.Tables.First(); - table2.Resize(table2.FirstCell(), table2.LastCell().CellLeft().CellAbove(3)); - - var ws3 = ws2.CopyTo("Sheet3"); - var table3 = ws3.Tables.First(); - table3.Resize(table3.FirstCell().CellLeft(), table3.LastCell().CellRight().CellBelow(1)); - - ////See #1492 - var ws4 = ws1.CopyTo("Sheet4"); - var table4 = ws4.Tables.First(); - table4.Field("String").Column.InsertColumnsAfter(1, true); - - wb.Worksheets.ForEach(ws => ws.Columns().AdjustToContents()); - wb.SaveAs(filePath); - } + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + + var data1 = Enumerable.Range(1, 10) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('a', i), + Integer = 64 + i + }); + + var table1 = ws1.Cell("B2").InsertTable(data1, true) + .SetShowHeaderRow() + .SetShowTotalsRow(); + + table1.Fields.First().TotalsRowLabel = "Sum of Integer"; + table1.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Sum; + + var ws2 = ws1.CopyTo("Sheet2"); + var table2 = ws2.Tables.First(); + table2.Resize(table2.FirstCell(), table2.LastCell().CellLeft().CellAbove(3)); + + var ws3 = ws2.CopyTo("Sheet3"); + var table3 = ws3.Tables.First(); + table3.Resize(table3.FirstCell().CellLeft(), table3.LastCell().CellRight().CellBelow(1)); + + ////See #1492 + var ws4 = ws1.CopyTo("Sheet4"); + var table4 = ws4.Tables.First(); + table4.Field("String").Column.InsertColumnsAfter(1, true); + + wb.Worksheets.ForEach(ws => ws.Columns().AdjustToContents()); + wb.SaveAs(filePath); } } } diff --git a/ClosedXML.Examples/Tables/UsingTables.cs b/ClosedXML.Examples/Tables/UsingTables.cs index 10414764b..9cef0444e 100644 --- a/ClosedXML.Examples/Tables/UsingTables.cs +++ b/ClosedXML.Examples/Tables/UsingTables.cs @@ -1,5 +1,4 @@ using ClosedXML.Excel; -using System; using System.IO; namespace ClosedXML.Examples.Tables @@ -9,94 +8,92 @@ public class UsingTables : IXLExample #region Methods // Public - public void Create(String filePath) + public void Create(string filePath) { - string tempFile = ExampleHelper.GetTempFilePath(filePath); + var tempFile = ExampleHelper.GetTempFilePath(filePath); try { new BasicTable().Create(tempFile); - using (var wb = new XLWorkbook(tempFile)) + using var wb = new XLWorkbook(tempFile); + var ws = wb.Worksheet(1); + ws.Name = "Contacts Table"; + var firstCell = ws.FirstCellUsed(); + var lastCell = ws.LastCellUsed(); + var range = ws.Range(firstCell.Address, lastCell.CellRight().Address); + range.FirstRow().Delete(); // Deleting the "Contacts" header (we don't need it for our purposes) + + // We want to use a theme for table, not the hard coded format of the BasicTable + range.Clear(XLClearOptions.AllFormats); + // Put back the date and number formats + range.Column(4).Style.NumberFormat.NumberFormatId = 15; + range.Column(5).Style.NumberFormat.Format = "$ #,##0"; + + // Add a field + range.Column(6).FirstCell().SetValue("Age"); + var c = range.Column(6).FirstCell().CellBelow(); + c.Style.NumberFormat.SetFormat("0.00"); + c.FormulaA1 = "=(DATE(2017, 10, 3) - E3) / 365"; + + c.CopyTo(c.CellBelow()) + .CopyTo(c.CellBelow().CellBelow()); + + var table = range.CreateTable(); // You can also use range.AsTable() if you want to + // manipulate the range as a table but don't want + // to create the table in the worksheet. + + // Let's activate the Totals row and add the sum of Income + table.ShowTotalsRow = true; + table.Field("Income").TotalsRowFunction = XLTotalsRowFunction.Sum; + // Just for fun let's add the text "Sum Of Income" to the totals row + table.Field(0).TotalsRowLabel = "Sum Of Income"; + + table.Field("Age").TotalsRowFunction = XLTotalsRowFunction.Average; + + // Copy all the headers + var columnWithHeaders = lastCell.Address.ColumnNumber + 3; + var currentRow = table.RangeAddress.FirstAddress.RowNumber; + ws.Cell(currentRow, columnWithHeaders).Value = "Table Headers"; + foreach (var cell in table.HeadersRow().Cells()) { - var ws = wb.Worksheet(1); - ws.Name = "Contacts Table"; - var firstCell = ws.FirstCellUsed(); - var lastCell = ws.LastCellUsed(); - var range = ws.Range(firstCell.Address, lastCell.CellRight().Address); - range.FirstRow().Delete(); // Deleting the "Contacts" header (we don't need it for our purposes) - - // We want to use a theme for table, not the hard coded format of the BasicTable - range.Clear(XLClearOptions.AllFormats); - // Put back the date and number formats - range.Column(4).Style.NumberFormat.NumberFormatId = 15; - range.Column(5).Style.NumberFormat.Format = "$ #,##0"; - - // Add a field - range.Column(6).FirstCell().SetValue("Age"); - var c = range.Column(6).FirstCell().CellBelow(); - c.Style.NumberFormat.SetFormat("0.00"); - c.FormulaA1 = "=(DATE(2017, 10, 3) - E3) / 365"; - - c.CopyTo(c.CellBelow()) - .CopyTo(c.CellBelow().CellBelow()); - - var table = range.CreateTable(); // You can also use range.AsTable() if you want to - // manipulate the range as a table but don't want - // to create the table in the worksheet. - - // Let's activate the Totals row and add the sum of Income - table.ShowTotalsRow = true; - table.Field("Income").TotalsRowFunction = XLTotalsRowFunction.Sum; - // Just for fun let's add the text "Sum Of Income" to the totals row - table.Field(0).TotalsRowLabel = "Sum Of Income"; - - table.Field("Age").TotalsRowFunction = XLTotalsRowFunction.Average; - - // Copy all the headers - Int32 columnWithHeaders = lastCell.Address.ColumnNumber + 3; - Int32 currentRow = table.RangeAddress.FirstAddress.RowNumber; - ws.Cell(currentRow, columnWithHeaders).Value = "Table Headers"; - foreach (var cell in table.HeadersRow().Cells()) - { - currentRow++; - ws.Cell(currentRow, columnWithHeaders).Value = cell.Value; - } - - // Format the headers as a table with a different style and no autofilters - var htFirstCell = ws.Cell(table.RangeAddress.FirstAddress.RowNumber, columnWithHeaders); - var htLastCell = ws.Cell(currentRow, columnWithHeaders); - var headersTable = ws.Range(htFirstCell, htLastCell).CreateTable("Headers"); - headersTable.Theme = XLTableTheme.TableStyleLight10; - headersTable.ShowAutoFilter = false; - - // Add a custom formula to the headersTable - headersTable.ShowTotalsRow = true; - headersTable.Field(0).TotalsRowFormulaA1 = "CONCATENATE(\"Count: \", CountA(Headers[Table Headers]))"; - - // Copy the names - Int32 columnWithNames = columnWithHeaders + 2; - currentRow = table.RangeAddress.FirstAddress.RowNumber; // reset the currentRow - ws.Cell(currentRow, columnWithNames).Value = "Names"; - foreach (var row in table.DataRange.Rows()) - { - currentRow++; - var fName = row.Field("FName").GetString(); // Notice how we're calling the cell by field name - var lName = row.Field("LName").GetString(); // Notice how we're calling the cell by field name - var name = String.Format("{0} {1}", fName, lName); - ws.Cell(currentRow, columnWithNames).Value = name; - } - - // Format the names as a table with a different style and no autofilters - var ntFirstCell = ws.Cell(table.RangeAddress.FirstAddress.RowNumber, columnWithNames); - var ntLastCell = ws.Cell(currentRow, columnWithNames); - var namesTable = ws.Range(ntFirstCell, ntLastCell).CreateTable(); - namesTable.Theme = XLTableTheme.TableStyleLight12; - namesTable.ShowAutoFilter = false; - - ws.Columns().AdjustToContents(); - ws.Columns("A,H,J").Width = 3; - - wb.SaveAs(filePath); + currentRow++; + ws.Cell(currentRow, columnWithHeaders).Value = cell.Value; } + + // Format the headers as a table with a different style and no autofilters + var htFirstCell = ws.Cell(table.RangeAddress.FirstAddress.RowNumber, columnWithHeaders); + var htLastCell = ws.Cell(currentRow, columnWithHeaders); + var headersTable = ws.Range(htFirstCell, htLastCell).CreateTable("Headers"); + headersTable.Theme = XLTableTheme.TableStyleLight10; + headersTable.ShowAutoFilter = false; + + // Add a custom formula to the headersTable + headersTable.ShowTotalsRow = true; + headersTable.Field(0).TotalsRowFormulaA1 = "CONCATENATE(\"Count: \", CountA(Headers[Table Headers]))"; + + // Copy the names + var columnWithNames = columnWithHeaders + 2; + currentRow = table.RangeAddress.FirstAddress.RowNumber; // reset the currentRow + ws.Cell(currentRow, columnWithNames).Value = "Names"; + foreach (var row in table.DataRange.Rows()) + { + currentRow++; + var fName = row.Field("FName").GetString(); // Notice how we're calling the cell by field name + var lName = row.Field("LName").GetString(); // Notice how we're calling the cell by field name + var name = string.Format("{0} {1}", fName, lName); + ws.Cell(currentRow, columnWithNames).Value = name; + } + + // Format the names as a table with a different style and no autofilters + var ntFirstCell = ws.Cell(table.RangeAddress.FirstAddress.RowNumber, columnWithNames); + var ntLastCell = ws.Cell(currentRow, columnWithNames); + var namesTable = ws.Range(ntFirstCell, ntLastCell).CreateTable(); + namesTable.Theme = XLTableTheme.TableStyleLight12; + namesTable.ShowAutoFilter = false; + + ws.Columns().AdjustToContents(); + ws.Columns("A,H,J").Width = 3; + + wb.SaveAs(filePath); } finally { diff --git a/ClosedXML.Sandbox/ClosedXML.Sandbox.csproj b/ClosedXML.Sandbox/ClosedXML.Sandbox.csproj index 127eb57c7..d8f46100c 100644 --- a/ClosedXML.Sandbox/ClosedXML.Sandbox.csproj +++ b/ClosedXML.Sandbox/ClosedXML.Sandbox.csproj @@ -1,48 +1,25 @@  - - - Exe - netcoreapp3.1;net40;net46 - 8.0 - 0.95.4 - $(NoWarn);NU1605 - Debug;Release - ClosedXML.Sandbox - ClosedXML.Sandbox - - - - $(DefineConstants);_NETSTANDARD_;_NETSTANDARD2_0_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET40_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET46_ - - - - - - - - - - - - - - - - - PreserveNewest - - - - - - + + Exe + net6.0 + 8.0 + 0.95.2 + Debug;Release + false + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + PreserveNewest + + + + + diff --git a/ClosedXML.Sandbox/OneRow.cs b/ClosedXML.Sandbox/OneRow.cs index 0293934f5..ce8c253a7 100644 --- a/ClosedXML.Sandbox/OneRow.cs +++ b/ClosedXML.Sandbox/OneRow.cs @@ -1,7 +1,4 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Web; using System.ComponentModel.DataAnnotations; namespace ClosedXML.Sandbox diff --git a/ClosedXML.Sandbox/PerformanceRunner.cs b/ClosedXML.Sandbox/PerformanceRunner.cs index 5a9724489..01e0ba671 100644 --- a/ClosedXML.Sandbox/PerformanceRunner.cs +++ b/ClosedXML.Sandbox/PerformanceRunner.cs @@ -23,13 +23,13 @@ public static void RunInsertTable() { var rows = new List(); - for (int i = 0; i < rowCount; i++) + for (var i = 0; i < rowCount; i++) { var row = GenerateRow(); rows.Add(row); } - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sheet 1"); worksheet.Cell(1, 1).InsertTable(rows); @@ -42,13 +42,11 @@ public static void RunInsertTable() public static void OpenTestFile() { - using (var wb = new XLWorkbook("test.xlsx")) - { - wb.RecalculateAllFormulas(); - var ws = wb.Worksheets.First(); - var cell = ws.FirstCellUsed(); - Console.WriteLine(cell.Value); - } + using var wb = new XLWorkbook("test.xlsx"); + wb.RecalculateAllFormulas(); + var ws = wb.Worksheets.First(); + var cell = ws.FirstCellUsed(); + Console.WriteLine(cell.Value); } private static void CreateMergedCell(IXLWorksheet worksheet) @@ -60,15 +58,13 @@ private static void CreateMergedCell(IXLWorksheet worksheet) private static void EmulateSave(XLWorkbook workbook) { - using (MemoryStream memoryStream = new MemoryStream()) - { - workbook.SaveAs(memoryStream); - memoryStream.Seek(0, SeekOrigin.Begin); - Console.WriteLine("Total bytes = " + memoryStream.ToArray().Length); - } + using var memoryStream = new MemoryStream(); + workbook.SaveAs(memoryStream); + memoryStream.Seek(0, SeekOrigin.Begin); + Console.WriteLine("Total bytes = " + memoryStream.ToArray().Length); } - private static Random rnd = new Random(); + private static readonly Random rnd = new Random(); private static T GenerateRow() where T : new() { @@ -86,9 +82,9 @@ private static void EmulateSave(XLWorkbook workbook) // Format strings var tmpString = new StringBuilder(); var tmpStringLength = rnd.Next(5, 50); - for (int x = 0; x <= tmpStringLength; x++) + for (var x = 0; x <= tmpStringLength; x++) { - tmpString.Append((char)(rnd.Next(48, 120))); + tmpString.Append((char)rnd.Next(48, 120)); } foreach (var str in strings) { @@ -96,7 +92,7 @@ private static void EmulateSave(XLWorkbook workbook) } // Format decimals - var tmpDec = (decimal)(rnd.Next(-10000, 100000) / (Math.Pow(10.0, rnd.Next(1, 4)))); + var tmpDec = (decimal)(rnd.Next(-10000, 100000) / Math.Pow(10.0, rnd.Next(1, 4))); foreach (var dec in decimals) { @@ -128,7 +124,7 @@ private static void EmulateSave(XLWorkbook workbook) } // Format booleans - var tmpBool = (rnd.Next(0, 2) > 0); + var tmpBool = rnd.Next(0, 2) > 0; foreach (var bl in booleans) { bl.SetValue(row, tmpBool, null); @@ -139,32 +135,30 @@ private static void EmulateSave(XLWorkbook workbook) public static void PerformHeavyCalculation() { - int rows = 200; - int columns = 200; - using (var wb = new XLWorkbook()) + var rows = 200; + var columns = 200; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var lastColumnLetter = sheet.Column(columns).ColumnLetter(); + for (var i = 1; i <= rows; i++) { - var sheet = wb.Worksheets.Add("TestSheet"); - var lastColumnLetter = sheet.Column(columns).ColumnLetter(); - for (int i = 1; i <= rows; i++) + for (var j = 1; j <= columns; j++) { - for (int j = 1; j <= columns; j++) + if (i == 1) { - if (i == 1) - { - sheet.Cell(i, j).FormulaA1 = string.Format("=ROUND({0}*SIN({0}),2)", j); - } - else - { - sheet.Cell(i, j).FormulaA1 = string.Format("=SUM({0}$1:{0}{1})/SUM($A{1}:${2}{1})", - sheet.Column(j).ColumnLetter(), i - 1, lastColumnLetter); // i.e. for K8 there will be =SUM(K$1:K7)/SUM($A7:$GR7) - } + sheet.Cell(i, j).FormulaA1 = string.Format("=ROUND({0}*SIN({0}),2)", j); + } + else + { + sheet.Cell(i, j).FormulaA1 = string.Format("=SUM({0}$1:{0}{1})/SUM($A{1}:${2}{1})", + sheet.Column(j).ColumnLetter(), i - 1, lastColumnLetter); // i.e. for K8 there will be =SUM(K$1:K7)/SUM($A7:$GR7) } } - - var cells = sheet.CellsUsed(); - var sum1 = cells.Sum(cell => (double)cell.Value); - Console.WriteLine("Total sum: {0:N2}", sum1); } + + var cells = sheet.CellsUsed(); + var sum1 = cells.Sum(cell => (double)cell.Value); + Console.WriteLine("Total sum: {0:N2}", sum1); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Sandbox/ReflectionExtensions.cs b/ClosedXML.Sandbox/ReflectionExtensions.cs deleted file mode 100644 index ed183eadc..000000000 --- a/ClosedXML.Sandbox/ReflectionExtensions.cs +++ /dev/null @@ -1,17 +0,0 @@ -#if _NET40_ -using System; -using System.Collections.Generic; -using System.Reflection; -using System.Text; - -namespace ClosedXML.Sandbox -{ - internal static class ReflectionExtensions - { - public static void SetValue(this PropertyInfo info, object obj, object value) - { - info.SetValue(obj, value, null); - } - } -} -#endif diff --git a/ClosedXML.Tests/ClosedXML.Tests.csproj b/ClosedXML.Tests/ClosedXML.Tests.csproj index 845ccef3d..b1311331f 100644 --- a/ClosedXML.Tests/ClosedXML.Tests.csproj +++ b/ClosedXML.Tests/ClosedXML.Tests.csproj @@ -1,64 +1,41 @@  - - netcoreapp3.1;net40;net46 - 8.0 - 0.95.4 - false - $(NoWarn);NU1605 - Debug;Release; - true - ..\ClosedXML.snk - ClosedXML.Tests - ClosedXML.Tests - - - - $(AppVeyor) - - - - $(DefineConstants);_NETSTANDARD_;_NETSTANDARD2_0_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET40_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET46_ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + net6.0;net48 + net6.0 + 8.0 + 0.95.2 + false + Debug;Release + false + true + ..\ClosedXML.snk + + + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + diff --git a/ClosedXML.Tests/Examples/AutoFilterTests.cs b/ClosedXML.Tests/Examples/AutoFilterTests.cs index eb1793dd5..ff76ac359 100644 --- a/ClosedXML.Tests/Examples/AutoFilterTests.cs +++ b/ClosedXML.Tests/Examples/AutoFilterTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -33,7 +34,7 @@ public void TopBottomAutoFilter() [Test] public void DateTimeGroupAutoFilter() { - TestHelper.RunTestExample(@"AutoFilter\DateTimeGroupAutoFilter.xlsx"); + TestHelper.RunTestExample(@"AutoFilter\DateTimeGroupAutoFilter.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } } diff --git a/ClosedXML.Tests/Examples/CommentsTests.cs b/ClosedXML.Tests/Examples/CommentsTests.cs index 555741016..b0ccbd306 100644 --- a/ClosedXML.Tests/Examples/CommentsTests.cs +++ b/ClosedXML.Tests/Examples/CommentsTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -9,7 +10,7 @@ public class CommentsTests [Test] public void AddingComments() { - TestHelper.RunTestExample(@"Comments\AddingComments.xlsx"); + TestHelper.RunTestExample(@"Comments\AddingComments.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } -} \ No newline at end of file +} diff --git a/ClosedXML.Tests/Examples/LoadingTests.cs b/ClosedXML.Tests/Examples/LoadingTests.cs index 79a734e00..949df9d9e 100644 --- a/ClosedXML.Tests/Examples/LoadingTests.cs +++ b/ClosedXML.Tests/Examples/LoadingTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -9,7 +10,7 @@ public class LoadingTests [Test] public void ChangingBasicTable() { - TestHelper.RunTestExample(@"Loading\ChangingBasicTable.xlsx"); + TestHelper.RunTestExample(@"Loading\ChangingBasicTable.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } -} \ No newline at end of file +} diff --git a/ClosedXML.Tests/Examples/MiscTests.cs b/ClosedXML.Tests/Examples/MiscTests.cs index 9fe326d06..66765ece4 100644 --- a/ClosedXML.Tests/Examples/MiscTests.cs +++ b/ClosedXML.Tests/Examples/MiscTests.cs @@ -1,6 +1,7 @@ using ClosedXML.Examples; using ClosedXML.Examples.Misc; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -10,25 +11,33 @@ public class MiscTests [Test] public void AddingDataSet() { - TestHelper.RunTestExample(@"Misc\AddingDataSet.xlsx"); + TestHelper.RunTestExample(@"Misc\AddingDataSet.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void AddingDataTableAsWorksheet() { - TestHelper.RunTestExample(@"Misc\AddingDataTableAsWorksheet.xlsx"); + TestHelper.RunTestExample(@"Misc\AddingDataTableAsWorksheet.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void AdjustToContents() { - TestHelper.RunTestExample(@"Misc\AdjustToContents.xlsx"); + // adjusted cell height depends on fonts available on the test system + var allowedDiff = "/xl/worksheets/sheet1.xml :NonEqual\n/xl/worksheets/sheet4.xml :NonEqual\n/xl/worksheets/sheet5.xml :NonEqual\n"; + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + allowedDiff = null; + } + + TestHelper.RunTestExample(@"Misc\AdjustToContents.xlsx", false, allowedDiff, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void AdjustToContentsWithAutoFilter() { - TestHelper.RunTestExample(@"Misc\AdjustToContentsWithAutoFilter.xlsx"); + TestHelper.RunTestExample(@"Misc\AdjustToContentsWithAutoFilter.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -40,7 +49,7 @@ public void AutoFilter() [Test] public void BasicTable() { - TestHelper.RunTestExample(@"Misc\BasicTable.xlsx"); + TestHelper.RunTestExample(@"Misc\BasicTable.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -52,13 +61,13 @@ public void BlankCells() [Test] public void CellValues() { - TestHelper.RunTestExample(@"Misc\CellValues.xlsx"); + TestHelper.RunTestExample(@"Misc\CellValues.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void Collections() { - TestHelper.RunTestExample(@"Misc\Collections.xlsx"); + TestHelper.RunTestExample(@"Misc\Collections.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -70,19 +79,19 @@ public void CopyingRowsAndColumns() [Test] public void CopyingWorksheets() { - TestHelper.RunTestExample(@"Misc\CopyingWorksheets.xlsx"); + TestHelper.RunTestExample(@"Misc\CopyingWorksheets.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void DataTypes() { - TestHelper.RunTestExample(@"Misc\DataTypes.xlsx"); + TestHelper.RunTestExample(@"Misc\DataTypes.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void DataTypesUnderDifferentCulture() { - TestHelper.RunTestExample(@"Misc\DataTypesUnderDifferentCulture.xlsx"); + TestHelper.RunTestExample(@"Misc\DataTypesUnderDifferentCulture.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -124,13 +133,13 @@ public void DataValidationTime() [Test] public void Formulas() { - TestHelper.RunTestExample(@"Misc\Formulas.xlsx"); + TestHelper.RunTestExample(@"Misc\Formulas.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void FormulasWithEvaluation() { - TestHelper.RunTestExample(@"Misc\FormulasWithEvaluation.xlsx", true); + TestHelper.RunTestExample(@"Misc\FormulasWithEvaluation.xlsx", true, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -154,19 +163,25 @@ public void HideUnhide() [Test] public void Hyperlinks() { - TestHelper.RunTestExample(@"Misc\Hyperlinks.xlsx"); + TestHelper.RunTestExample(@"Misc\Hyperlinks.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void InsertingData() { - TestHelper.RunTestExample(@"Misc\InsertingData.xlsx"); + var exepectation = @"Misc\InsertingData.xlsx"; + +#if NETFRAMEWORK + exepectation = @"Misc\InsertingDataNetFramework.xlsx"; +#endif + + TestHelper.RunTestExample(exepectation, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void LambdaExpressions() { - TestHelper.RunTestExample(@"Misc\LambdaExpressions.xlsx"); + TestHelper.RunTestExample(@"Misc\LambdaExpressions.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -196,7 +211,7 @@ public void RightToLeft() [Test] public void SheetProtection() { - TestHelper.RunTestExample(@"Misc\SheetProtection.xlsx"); + TestHelper.RunTestExample(@"Misc\SheetProtection.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -214,7 +229,7 @@ public void ShiftingFormulas() [Test] public void ShowCase() { - TestHelper.RunTestExample(@"Misc\ShowCase.xlsx"); + TestHelper.RunTestExample(@"Misc\ShowCase.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -235,4 +250,4 @@ public void WorkbookProtection() TestHelper.RunTestExample(@"Misc\WorkbookProtection.xlsx"); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Examples/PivotTableTests.cs b/ClosedXML.Tests/Examples/PivotTableTests.cs index aeaaf2444..bb9cee349 100644 --- a/ClosedXML.Tests/Examples/PivotTableTests.cs +++ b/ClosedXML.Tests/Examples/PivotTableTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -9,7 +10,7 @@ public class PivotTableTests [Test] public void PivotTables() { - TestHelper.RunTestExample(@"PivotTables\PivotTables.xlsx"); + TestHelper.RunTestExample(@"PivotTables\PivotTables.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } } diff --git a/ClosedXML.Tests/Examples/RangesTests.cs b/ClosedXML.Tests/Examples/RangesTests.cs index 4b2225a37..75302d432 100644 --- a/ClosedXML.Tests/Examples/RangesTests.cs +++ b/ClosedXML.Tests/Examples/RangesTests.cs @@ -2,6 +2,7 @@ using ClosedXML.Examples.Misc; using ClosedXML.Examples.Ranges; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -17,13 +18,13 @@ public void ClearingRanges() [Test] public void CopyingRanges() { - TestHelper.RunTestExample(@"Ranges\CopyingRanges.xlsx"); + TestHelper.RunTestExample(@"Ranges\CopyingRanges.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void CurrentRowColumn() { - TestHelper.RunTestExample(@"Ranges\CurrentRowColumn.xlsx"); + TestHelper.RunTestExample(@"Ranges\CurrentRowColumn.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -59,7 +60,7 @@ public void MultipleRanges() [Test] public void NamedRanges() { - TestHelper.RunTestExample(@"Ranges\NamedRanges.xlsx"); + TestHelper.RunTestExample(@"Ranges\NamedRanges.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -71,7 +72,7 @@ public void SelectingRanges() [Test] public void ShiftingRanges() { - TestHelper.RunTestExample(@"Ranges\ShiftingRanges.xlsx"); + TestHelper.RunTestExample(@"Ranges\ShiftingRanges.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -89,19 +90,19 @@ public void Sorting() [Test] public void TransposeRanges() { - TestHelper.RunTestExample(@"Ranges\TransposeRanges.xlsx"); + TestHelper.RunTestExample(@"Ranges\TransposeRanges.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void TransposeRangesPlus() { - TestHelper.RunTestExample(@"Ranges\TransposeRangesPlus.xlsx"); + TestHelper.RunTestExample(@"Ranges\TransposeRangesPlus.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void AddingRowToTables() { - TestHelper.RunTestExample(@"Ranges\AddingRowToTables.xlsx"); + TestHelper.RunTestExample(@"Ranges\AddingRowToTables.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] diff --git a/ClosedXML.Tests/Examples/StylesTests.cs b/ClosedXML.Tests/Examples/StylesTests.cs index fd6605e63..641b37232 100644 --- a/ClosedXML.Tests/Examples/StylesTests.cs +++ b/ClosedXML.Tests/Examples/StylesTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples.Styles; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -39,19 +40,19 @@ public void StyleFill() [Test] public void StyleFont() { - TestHelper.RunTestExample(@"Styles\StyleFont.xlsx"); + TestHelper.RunTestExample(@"Styles\StyleFont.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void StyleNumberFormat() { - TestHelper.RunTestExample(@"Styles\StyleNumberFormat.xlsx"); + TestHelper.RunTestExample(@"Styles\StyleNumberFormat.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void StyleIncludeQuotePrefix() { - TestHelper.RunTestExample(@"Styles\StyleIncludeQuotePrefix.xlsx"); + TestHelper.RunTestExample(@"Styles\StyleIncludeQuotePrefix.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -69,7 +70,7 @@ public void StyleWorksheet() [Test] public void UsingColors() { - TestHelper.RunTestExample(@"Styles\UsingColors.xlsx"); + TestHelper.RunTestExample(@"Styles\UsingColors.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] @@ -81,7 +82,7 @@ public void UsingPhonetics() [Test] public void UsingRichText() { - TestHelper.RunTestExample(@"Styles\UsingRichText.xlsx"); + TestHelper.RunTestExample(@"Styles\UsingRichText.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } } diff --git a/ClosedXML.Tests/Examples/TablesTests.cs b/ClosedXML.Tests/Examples/TablesTests.cs index 61422fd04..bf642acbc 100644 --- a/ClosedXML.Tests/Examples/TablesTests.cs +++ b/ClosedXML.Tests/Examples/TablesTests.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples.Tables; using NUnit.Framework; +using System.Runtime.InteropServices; namespace ClosedXML.Tests.Examples { @@ -9,19 +10,19 @@ public class TablesTests [Test] public void InsertingTables() { - TestHelper.RunTestExample(@"Tables\InsertingTables.xlsx"); + TestHelper.RunTestExample(@"Tables\InsertingTables.xlsx", false, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void ResizingTables() { - TestHelper.RunTestExample(@"Tables\ResizingTables.xlsx"); + TestHelper.RunTestExample(@"Tables\ResizingTables.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void UsingTables() { - TestHelper.RunTestExample(@"Tables\UsingTables.xlsx"); + TestHelper.RunTestExample(@"Tables\UsingTables.xlsx", ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } } } diff --git a/ClosedXML.Tests/Excel/AutoFilters/AutoFilterTests.cs b/ClosedXML.Tests/Excel/AutoFilters/AutoFilterTests.cs index 067e727f7..18c7ee387 100644 --- a/ClosedXML.Tests/Excel/AutoFilters/AutoFilterTests.cs +++ b/ClosedXML.Tests/Excel/AutoFilters/AutoFilterTests.cs @@ -7,7 +7,7 @@ using System.Linq; using System.Threading; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.AutoFilters { [TestFixture] public class AutoFilterTests @@ -15,50 +15,48 @@ public class AutoFilterTests [Test] public void AutoFilterExpandsWithTable() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); - ws.FirstCell().SetValue("Categories") - .CellBelow().SetValue("1") - .CellBelow().SetValue("2"); + ws.FirstCell().SetValue("Categories") + .CellBelow().SetValue("1") + .CellBelow().SetValue("2"); - IXLTable table = ws.RangeUsed().CreateTable(); + var table = ws.RangeUsed().CreateTable(); - var listOfArr = new List(); - listOfArr.Add(3); - listOfArr.Add(4); - listOfArr.Add(5); - listOfArr.Add(6); + var listOfArr = new List + { + 3, + 4, + 5, + 6 + }; - table.DataRange.InsertRowsBelow(listOfArr.Count - table.DataRange.RowCount()); - table.DataRange.FirstCell().InsertData(listOfArr); + table.DataRange.InsertRowsBelow(listOfArr.Count - table.DataRange.RowCount()); + table.DataRange.FirstCell().InsertData(listOfArr); - Assert.AreEqual("A1:A5", table.AutoFilter.Range.RangeAddress.ToStringRelative()); - Assert.AreEqual(5, table.AutoFilter.VisibleRows.Count()); - } + Assert.AreEqual("A1:A5", table.AutoFilter.Range.RangeAddress.ToStringRelative()); + Assert.AreEqual(5, table.AutoFilter.VisibleRows.Count()); } [Test] public void AutoFilterSortWhenNotInFirstRow() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Cell(3, 3).SetValue("Names") - .CellBelow().SetValue("Manuel") - .CellBelow().SetValue("Carlos") - .CellBelow().SetValue("Dominic"); - ws.RangeUsed().SetAutoFilter().Sort(); - Assert.AreEqual("Carlos", ws.Cell(4, 3).GetString()); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Cell(3, 3).SetValue("Names") + .CellBelow().SetValue("Manuel") + .CellBelow().SetValue("Carlos") + .CellBelow().SetValue("Dominic"); + ws.RangeUsed().SetAutoFilter().Sort(); + Assert.AreEqual("Carlos", ws.Cell(4, 3).GetString()); } [Test] public void CanClearAutoFilter() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("AutoFilter"); ws.Cell("A1").Value = "Names"; ws.Cell("A2").Value = "John"; @@ -78,52 +76,48 @@ public void CanClearAutoFilter() [Test] public void CanClearAutoFilter2() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("AutoFilter"); - ws.Cell("A1").Value = "Names"; - ws.Cell("A2").Value = "John"; - ws.Cell("A3").Value = "Hank"; - ws.Cell("A4").Value = "Dagny"; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("AutoFilter"); + ws.Cell("A1").Value = "Names"; + ws.Cell("A2").Value = "John"; + ws.Cell("A3").Value = "Hank"; + ws.Cell("A4").Value = "Dagny"; - ws.SetAutoFilter(false); - Assert.That(!ws.AutoFilter.IsEnabled); + ws.SetAutoFilter(false); + Assert.That(!ws.AutoFilter.IsEnabled); - ws.RangeUsed().SetAutoFilter(); - Assert.That(ws.AutoFilter.IsEnabled); + ws.RangeUsed().SetAutoFilter(); + Assert.That(ws.AutoFilter.IsEnabled); - ws.RangeUsed().SetAutoFilter(false); - Assert.That(!ws.AutoFilter.IsEnabled); - } + ws.RangeUsed().SetAutoFilter(false); + Assert.That(!ws.AutoFilter.IsEnabled); } [Test] public void CanCopyAutoFilterToNewSheetOnNewWorkbook() { - using (var ms1 = new MemoryStream()) - using (var ms2 = new MemoryStream()) + using var ms1 = new MemoryStream(); + using var ms2 = new MemoryStream(); + using (var wb1 = new XLWorkbook()) + using (var wb2 = new XLWorkbook()) { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws = wb1.Worksheets.Add("AutoFilter"); - ws.Cell("A1").Value = "Names"; - ws.Cell("A2").Value = "John"; - ws.Cell("A3").Value = "Hank"; - ws.Cell("A4").Value = "Dagny"; + var ws = wb1.Worksheets.Add("AutoFilter"); + ws.Cell("A1").Value = "Names"; + ws.Cell("A2").Value = "John"; + ws.Cell("A3").Value = "Hank"; + ws.Cell("A4").Value = "Dagny"; - ws.RangeUsed().SetAutoFilter(); + ws.RangeUsed().SetAutoFilter(); - wb1.SaveAs(ms1); + wb1.SaveAs(ms1); - ws.CopyTo(wb2, ws.Name); - wb2.SaveAs(ms2); - } + ws.CopyTo(wb2, ws.Name); + wb2.SaveAs(ms2); + } - using (var wb2 = new XLWorkbook(ms2)) - { - Assert.IsTrue(wb2.Worksheets.First().AutoFilter.IsEnabled); - } + using (var wb2 = new XLWorkbook(ms2)) + { + Assert.IsTrue(wb2.Worksheets.First().AutoFilter.IsEnabled); } } @@ -151,81 +145,73 @@ public void CannotAddAutoFilterOverExistingTable() public void AutoFilterRangeRemainsValidOnInsertColumn(string rangeAddress) { //Arrange - using (var ms1 = new MemoryStream()) - { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("AutoFilter"); - ws.Cell("A1").Value = "Ids"; - ws.Cell("B1").Value = "Names"; - ws.Cell("B2").Value = "John"; - ws.Cell("B3").Value = "Hank"; - ws.Cell("B4").Value = "Dagny"; - ws.Cell("C1").Value = "Phones"; - - ws.Range("B1:B4").SetAutoFilter(true); - - //Act - var range = ws.Range(rangeAddress); - range.InsertColumnsBefore(1); - - //Assert - Assert.IsTrue(ws.AutoFilter.Range.RangeAddress.IsValid); - } - } + using var ms1 = new MemoryStream(); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("AutoFilter"); + ws.Cell("A1").Value = "Ids"; + ws.Cell("B1").Value = "Names"; + ws.Cell("B2").Value = "John"; + ws.Cell("B3").Value = "Hank"; + ws.Cell("B4").Value = "Dagny"; + ws.Cell("C1").Value = "Phones"; + + ws.Range("B1:B4").SetAutoFilter(true); + + //Act + var range = ws.Range(rangeAddress); + range.InsertColumnsBefore(1); + + //Assert + Assert.IsTrue(ws.AutoFilter.Range.RangeAddress.IsValid); } [Test] public void AutoFilterVisibleRows() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(3, 3).SetValue("Names") - .CellBelow().SetValue("Manuel") - .CellBelow().SetValue("Carlos") - .CellBelow().SetValue("Dominic"); + ws.Cell(3, 3).SetValue("Names") + .CellBelow().SetValue("Manuel") + .CellBelow().SetValue("Carlos") + .CellBelow().SetValue("Dominic"); - var autoFilter = ws.RangeUsed() - .SetAutoFilter(); + var autoFilter = ws.RangeUsed() + .SetAutoFilter(); - autoFilter.Column(1).AddFilter("Carlos"); + autoFilter.Column(1).AddFilter("Carlos"); - Assert.AreEqual("Carlos", ws.Cell(5, 3).GetString()); - Assert.AreEqual(2, autoFilter.VisibleRows.Count()); - Assert.AreEqual(3, autoFilter.VisibleRows.First().WorksheetRow().RowNumber()); - Assert.AreEqual(5, autoFilter.VisibleRows.Last().WorksheetRow().RowNumber()); - } + Assert.AreEqual("Carlos", ws.Cell(5, 3).GetString()); + Assert.AreEqual(2, autoFilter.VisibleRows.Count()); + Assert.AreEqual(3, autoFilter.VisibleRows.First().WorksheetRow().RowNumber()); + Assert.AreEqual(5, autoFilter.VisibleRows.Last().WorksheetRow().RowNumber()); } [Test] public void ReapplyAutoFilter() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(3, 3).SetValue("Names") - .CellBelow().SetValue("Manuel") - .CellBelow().SetValue("Carlos") - .CellBelow().SetValue("Dominic") - .CellBelow().SetValue("Jose"); + ws.Cell(3, 3).SetValue("Names") + .CellBelow().SetValue("Manuel") + .CellBelow().SetValue("Carlos") + .CellBelow().SetValue("Dominic") + .CellBelow().SetValue("Jose"); - var autoFilter = ws.RangeUsed() - .SetAutoFilter(); + var autoFilter = ws.RangeUsed() + .SetAutoFilter(); - autoFilter.Column(1).AddFilter("Carlos"); + autoFilter.Column(1).AddFilter("Carlos"); - Assert.AreEqual(3, autoFilter.HiddenRows.Count()); + Assert.AreEqual(3, autoFilter.HiddenRows.Count()); - // Unhide the rows so that the table is out of sync with the filter - autoFilter.HiddenRows.ForEach(r => r.WorksheetRow().Unhide()); - Assert.False(autoFilter.HiddenRows.Any()); + // Unhide the rows so that the table is out of sync with the filter + autoFilter.HiddenRows.ForEach(r => r.WorksheetRow().Unhide()); + Assert.False(autoFilter.HiddenRows.Any()); - autoFilter.Reapply(); - Assert.AreEqual(3, autoFilter.HiddenRows.Count()); - } + autoFilter.Reapply(); + Assert.AreEqual(3, autoFilter.HiddenRows.Count()); } [Test] @@ -261,7 +247,7 @@ public void CanLoadAutoFilterWithThousandsSeparator() var ws = wb.Worksheets.First(); Assert.AreEqual("10 000.00", (ws.AutoFilter as XLAutoFilter).Filters.First().Value.First().Value); - var v = ws.AutoFilter.VisibleRows.Select(r => r.FirstCell().Value).ToList(); + _ = ws.AutoFilter.VisibleRows.Select(r => r.FirstCell().Value).ToList(); Assert.AreEqual(2, ws.AutoFilter.VisibleRows.Count()); ws.AutoFilter.Reapply(); @@ -274,4 +260,4 @@ public void CanLoadAutoFilterWithThousandsSeparator() } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Caching/SampleRepositoryTests.cs b/ClosedXML.Tests/Excel/Caching/SampleRepositoryTests.cs index 32379a8d7..3db3dfa71 100644 --- a/ClosedXML.Tests/Excel/Caching/SampleRepositoryTests.cs +++ b/ClosedXML.Tests/Excel/Caching/SampleRepositoryTests.cs @@ -13,10 +13,10 @@ public class BaseRepositoryTests public void DifferentEntitiesWithSameKeyStoredOnce() { // Arrange - int key = 12345; + var key = 12345; var entity1 = new SampleEntity(key); var entity2 = new SampleEntity(key); - var sampleRepository = this.CreateSampleRepository(); + var sampleRepository = CreateSampleRepository(); // Act var storedEntity1 = sampleRepository.Store(ref key, entity1); @@ -98,18 +98,18 @@ public void NonUsedReferencesAreGCed2() public void ConcurrentAddingCausesNoDuplication() { // Arrange - int countUnique = 30; - int repeatCount = 1000; - SampleEntity[] entities = new SampleEntity[countUnique * repeatCount]; - for (int i = 0; i < countUnique; i++) + var countUnique = 30; + var repeatCount = 1000; + var entities = new SampleEntity[countUnique * repeatCount]; + for (var i = 0; i < countUnique; i++) { - for (int j = 0; j < repeatCount; j++) + for (var j = 0; j < repeatCount; j++) { entities[i * repeatCount + j] = new SampleEntity(i); } } - var sampleRepository = this.CreateSampleRepository(); + var sampleRepository = CreateSampleRepository(); // Act Parallel.ForEach(entities, new ParallelOptions { MaxDegreeOfParallelism = 8 }, @@ -129,16 +129,16 @@ public void ConcurrentAddingCausesNoDuplication() public void ReplaceKeyInRepository() { // Arrange - int key1 = 12345; - int key2 = 54321; + var key1 = 12345; + var key2 = 54321; var entity = new SampleEntity(key1); - var sampleRepository = this.CreateSampleRepository(); + var sampleRepository = CreateSampleRepository(); var storedEntity1 = sampleRepository.Store(ref key1, entity); // Act sampleRepository.Replace(ref key1, ref key2); - bool containsOld = sampleRepository.ContainsKey(ref key1, out var _); - bool containsNew = sampleRepository.ContainsKey(ref key2, out var _); + var containsOld = sampleRepository.ContainsKey(ref key1, out var _); + var containsNew = sampleRepository.ContainsKey(ref key2, out var _); var storedEntity2 = sampleRepository.GetOrCreate(ref key2); // Assert @@ -152,7 +152,7 @@ public void ReplaceKeyInRepository() public void ConcurrentReplaceKeyInRepository() { var sampleRepository = new EditableRepository(); - int[] keys = Enumerable.Range(0, 1000).ToArray(); + var keys = Enumerable.Range(0, 1000).ToArray(); keys.ForEach(key => sampleRepository.GetOrCreate(ref key)); Parallel.ForEach(keys, key => @@ -168,11 +168,11 @@ public void ConcurrentReplaceKeyInRepository() [Test] public void ReplaceNonExistingKeyInRepository() { - int key1 = 100; - int key2 = 200; - int key3 = 300; + var key1 = 100; + var key2 = 200; + var key3 = 300; var entity = new SampleEntity(key1); - var sampleRepository = this.CreateSampleRepository(); + var sampleRepository = CreateSampleRepository(); sampleRepository.Store(ref key1, entity); sampleRepository.Replace(ref key2, ref key3); diff --git a/ClosedXML.Tests/Excel/CalcEngine/CalcEngineCellEnumerationTests.cs b/ClosedXML.Tests/Excel/CalcEngine/CalcEngineCellEnumerationTests.cs index 64f120925..ac548654d 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/CalcEngineCellEnumerationTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/CalcEngineCellEnumerationTests.cs @@ -8,16 +8,14 @@ public class CalcEngineCellEnumerationTests [Test] public void CanEnumerateCellsOverEmptySheet() { - using (var wb = new XLWorkbook()) - { - var sheet1 = wb.AddWorksheet("Sheet1"); - var sheet2 = wb.AddWorksheet("Sheet2"); + using var wb = new XLWorkbook(); + var sheet1 = wb.AddWorksheet("Sheet1"); + var sheet2 = wb.AddWorksheet("Sheet2"); - var cell = sheet1.FirstCell(); - cell.FormulaA1 = "=SUMIFS(Sheet2!B:B, Sheet2!C:C, 1)"; + var cell = sheet1.FirstCell(); + cell.FormulaA1 = "=SUMIFS(Sheet2!B:B, Sheet2!C:C, 1)"; - Assert.AreEqual(0, cell.Value); - } + Assert.AreEqual(0, cell.Value); } } } diff --git a/ClosedXML.Tests/Excel/CalcEngine/CalcEngineExceptionTests.cs b/ClosedXML.Tests/Excel/CalcEngine/CalcEngineExceptionTests.cs index 8ca0b09be..7d363885f 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/CalcEngineExceptionTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/CalcEngineExceptionTests.cs @@ -37,7 +37,8 @@ public void InvalidFunction() ex = Assert.Throws(() => XLWorkbook.EvaluateExpr("XXX(A1:A2)")); Assert.That(ex.Message, Is.EqualTo("The identifier `XXX` was not recognised.")); - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); ex = Assert.Throws(() => ws.Evaluate("XXX(A1:A2)")); Assert.That(ex.Message, Is.EqualTo("The identifier `XXX` was not recognised.")); } @@ -53,4 +54,4 @@ public void NestedNameNotRecognizedException() Assert.AreEqual("Success", ws.Cell("A2").Value); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/DateAndTimeTests.cs b/ClosedXML.Tests/Excel/CalcEngine/DateAndTimeTests.cs index 1f3c862a9..6c5f074ba 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/DateAndTimeTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/DateAndTimeTests.cs @@ -5,7 +5,7 @@ using System.Globalization; using System.Threading; -namespace ClosedXML.Tests.Excel.DataValidations +namespace ClosedXML.Tests.Excel.CalcEngine { [TestFixture] public class DateAndTimeTests @@ -19,7 +19,7 @@ public void SetCultureInfo() [Test] public void Date() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr("Date(2008, 1, 1)"); Assert.AreEqual(39448, actual); @@ -64,8 +64,16 @@ public void Date() [TestCase("2020-11-22", "2020-11-23 9:00", "D", ExpectedResult = 1)] public double Datedif(object startDate, object endDate, string unit) { - if (startDate is string s1) startDate = $"\"{s1}\""; - if (endDate is string s2) endDate = $"\"{s2}\""; + if (startDate is string s1) + { + startDate = $"\"{s1}\""; + } + + if (endDate is string s2) + { + endDate = $"\"{s2}\""; + } + return (double)XLWorkbook.EvaluateExpr($"DATEDIF({startDate}, {endDate}, \"{unit}\")"); } @@ -81,21 +89,21 @@ public void DatedifExceptions(object startDate, object endDate, string unit) [Test] public void Datevalue() { - Object actual = XLWorkbook.EvaluateExpr("DateValue(\"8/22/2008\")"); + var actual = XLWorkbook.EvaluateExpr("DateValue(\"8/22/2008\")"); Assert.AreEqual(39682, actual); } [Test] public void Day() { - Object actual = XLWorkbook.EvaluateExpr("Day(\"8/22/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Day(\"8/22/2008\")"); Assert.AreEqual(22, actual); } [Test] public void Days() { - Object actual = XLWorkbook.EvaluateExpr("DAYS(DATE(2016,10,1),DATE(1992,2,29))"); + var actual = XLWorkbook.EvaluateExpr("DAYS(DATE(2016,10,1),DATE(1992,2,29))"); Assert.AreEqual(8981, actual); actual = XLWorkbook.EvaluateExpr("DAYS(\"2016-10-1\",\"1992-2-29\")"); @@ -105,115 +113,115 @@ public void Days() [Test] public void DayWithDifferentCulture() { - CultureInfo ci = new CultureInfo(CultureInfo.InvariantCulture.LCID); + var ci = new CultureInfo(CultureInfo.InvariantCulture.LCID); ci.DateTimeFormat.ShortDatePattern = "dd/MM/yyyy"; Thread.CurrentThread.CurrentCulture = ci; - Object actual = XLWorkbook.EvaluateExpr("Day(\"1/6/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Day(\"1/6/2008\")"); Assert.AreEqual(1, actual); } [Test] public void Days360_Default() { - Object actual = XLWorkbook.EvaluateExpr("Days360(\"1/30/2008\", \"2/1/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Days360(\"1/30/2008\", \"2/1/2008\")"); Assert.AreEqual(1, actual); } [Test] public void Days360_Europe1() { - Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",TRUE)"); + var actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",TRUE)"); Assert.AreEqual(89, actual); } [Test] public void Days360_Europe2() { - Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",TRUE)"); + var actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",TRUE)"); Assert.AreEqual(-89, actual); } [Test] public void Days360_US1() { - Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",FALSE)"); + var actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",FALSE)"); Assert.AreEqual(90, actual); } [Test] public void Days360_US2() { - Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",FALSE)"); + var actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",FALSE)"); Assert.AreEqual(-89, actual); } [Test] public void EDate_Negative1() { - Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", -1)"); + var actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", -1)"); Assert.AreEqual(new DateTime(2008, 2, 1), actual); } [Test] public void EDate_Negative2() { - Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", -1)"); + var actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", -1)"); Assert.AreEqual(new DateTime(2008, 2, 29), actual); } [Test] public void EDate_Positive1() { - Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", 1)"); + var actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", 1)"); Assert.AreEqual(new DateTime(2008, 4, 1), actual); } [Test] public void EDate_Positive2() { - Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", 1)"); + var actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", 1)"); Assert.AreEqual(new DateTime(2008, 4, 30), actual); } [Test] public void EOMonth_Negative() { - Object actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/1/2008\", -1)"); + var actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/1/2008\", -1)"); Assert.AreEqual(new DateTime(2008, 2, 29), actual); } [Test] public void EOMonth_Positive() { - Object actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/31/2008\", 1)"); + var actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/31/2008\", 1)"); Assert.AreEqual(new DateTime(2008, 4, 30), actual); } [Test] public void Hour() { - Object actual = XLWorkbook.EvaluateExpr("Hour(\"8/22/2008 3:30:45 PM\")"); + var actual = XLWorkbook.EvaluateExpr("Hour(\"8/22/2008 3:30:45 PM\")"); Assert.AreEqual(15, actual); } [Test] public void Minute() { - Object actual = XLWorkbook.EvaluateExpr("Minute(\"8/22/2008 3:30:45 AM\")"); + var actual = XLWorkbook.EvaluateExpr("Minute(\"8/22/2008 3:30:45 AM\")"); Assert.AreEqual(30, actual); } [Test] public void Month() { - Object actual = XLWorkbook.EvaluateExpr("Month(\"8/22/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Month(\"8/22/2008\")"); Assert.AreEqual(8, actual); } [Test] public void IsoWeekNum() { - Object actual = XLWorkbook.EvaluateExpr("ISOWEEKNUM(DATEVALUE(\"2012-3-9\"))"); + var actual = XLWorkbook.EvaluateExpr("ISOWEEKNUM(DATEVALUE(\"2012-3-9\"))"); Assert.AreEqual(10, actual); actual = XLWorkbook.EvaluateExpr("ISOWEEKNUM(DATE(2012,12,31))"); @@ -223,29 +231,29 @@ public void IsoWeekNum() [Test] public void Networkdays_MultipleHolidaysGiven() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Date") .CellBelow().SetValue(new DateTime(2008, 10, 1)) .CellBelow().SetValue(new DateTime(2009, 3, 1)) .CellBelow().SetValue(new DateTime(2008, 11, 26)) .CellBelow().SetValue(new DateTime(2008, 12, 4)) .CellBelow().SetValue(new DateTime(2009, 1, 21)); - Object actual = ws.Evaluate("Networkdays(A2,A3,A4:A6)"); + var actual = ws.Evaluate("Networkdays(A2,A3,A4:A6)"); Assert.AreEqual(105, actual); } [Test] public void Networkdays_NoHolidaysGiven() { - Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\")"); + var actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\")"); Assert.AreEqual(108, actual); } [Test] public void Networkdays_NegativeResult() { - Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"3/01/2009\", \"10/01/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Networkdays(\"3/01/2009\", \"10/01/2008\")"); Assert.AreEqual(-108, actual); actual = XLWorkbook.EvaluateExpr("Networkdays(\"2016-01-01\", \"2015-12-23\")"); @@ -255,70 +263,70 @@ public void Networkdays_NegativeResult() [Test] public void Networkdays_OneHolidaysGiven() { - Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\", \"11/26/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\", \"11/26/2008\")"); Assert.AreEqual(107, actual); } [Test] public void Second() { - Object actual = XLWorkbook.EvaluateExpr("Second(\"8/22/2008 3:30:45 AM\")"); + var actual = XLWorkbook.EvaluateExpr("Second(\"8/22/2008 3:30:45 AM\")"); Assert.AreEqual(45, actual); } [Test] public void Time() { - Object actual = XLWorkbook.EvaluateExpr("Time(1,2,3)"); + var actual = XLWorkbook.EvaluateExpr("Time(1,2,3)"); Assert.AreEqual(new TimeSpan(1, 2, 3), actual); } [Test] public void TimeValue1() { - Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"2:24 AM\")"); + var actual = XLWorkbook.EvaluateExpr("TimeValue(\"2:24 AM\")"); Assert.IsTrue(XLHelper.AreEqual(0.1, (double)actual)); } [Test] public void TimeValue2() { - Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"22-Aug-2008 6:35 AM\")"); + var actual = XLWorkbook.EvaluateExpr("TimeValue(\"22-Aug-2008 6:35 AM\")"); Assert.IsTrue(XLHelper.AreEqual(0.27430555555555558, (double)actual)); } [Test] public void Today() { - Object actual = XLWorkbook.EvaluateExpr("Today()"); + var actual = XLWorkbook.EvaluateExpr("Today()"); Assert.AreEqual(DateTime.Now.Date, actual); } [Test] public void Weekday_1() { - Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 1)"); + var actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 1)"); Assert.AreEqual(5, actual); } [Test] public void Weekday_2() { - Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 2)"); + var actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 2)"); Assert.AreEqual(4, actual); } [Test] public void Weekday_3() { - Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 3)"); + var actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 3)"); Assert.AreEqual(3, actual); } [Test] public void Weekday_Omitted() { - Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\")"); Assert.AreEqual(5, actual); } @@ -445,29 +453,29 @@ public void Weeknum_9() [Test] public void Weeknum_Default() { - Object actual = XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\")"); Assert.AreEqual(11, actual); } [Test] public void Workdays_MultipleHolidaysGiven() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Date") .CellBelow().SetValue(new DateTime(2008, 10, 1)) .CellBelow().SetValue(151) .CellBelow().SetValue(new DateTime(2008, 11, 26)) .CellBelow().SetValue(new DateTime(2008, 12, 4)) .CellBelow().SetValue(new DateTime(2009, 1, 21)); - Object actual = ws.Evaluate("Workday(A2,A3,A4:A6)"); + var actual = ws.Evaluate("Workday(A2,A3,A4:A6)"); Assert.AreEqual(new DateTime(2009, 5, 5), actual); } [Test] public void Workdays_NoHolidaysGiven() { - Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 151)"); + var actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 151)"); Assert.AreEqual(new DateTime(2009, 4, 30), actual); actual = XLWorkbook.EvaluateExpr("Workday(\"2016-01-01\", -10)"); @@ -477,85 +485,85 @@ public void Workdays_NoHolidaysGiven() [Test] public void Workdays_OneHolidaysGiven() { - Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 152, \"11/26/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 152, \"11/26/2008\")"); Assert.AreEqual(new DateTime(2009, 5, 4), actual); } [Test] public void Year() { - Object actual = XLWorkbook.EvaluateExpr("Year(\"8/22/2008\")"); + var actual = XLWorkbook.EvaluateExpr("Year(\"8/22/2008\")"); Assert.AreEqual(2008, actual); } [Test] public void Yearfrac_1_base0() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",0)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",0)"); Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual)); } [Test] public void Yearfrac_1_base1() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",1)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",1)"); Assert.IsTrue(XLHelper.AreEqual(0.24590163934426229, (double)actual)); } [Test] public void Yearfrac_1_base2() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",2)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",2)"); Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual)); } [Test] public void Yearfrac_1_base3() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",3)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",3)"); Assert.IsTrue(XLHelper.AreEqual(0.24657534246575341, (double)actual)); } [Test] public void Yearfrac_1_base4() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",4)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",4)"); Assert.IsTrue(XLHelper.AreEqual(0.24722222222222223, (double)actual)); } [Test] public void Yearfrac_2_base0() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",0)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",0)"); Assert.IsTrue(XLHelper.AreEqual(5.25, (double)actual)); } [Test] public void Yearfrac_2_base1() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",1)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",1)"); Assert.IsTrue(XLHelper.AreEqual(5.24452554744526, (double)actual)); } [Test] public void Yearfrac_2_base2() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",2)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",2)"); Assert.IsTrue(XLHelper.AreEqual(5.32222222222222, (double)actual)); } [Test] public void Yearfrac_2_base3() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",3)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",3)"); Assert.IsTrue(XLHelper.AreEqual(5.24931506849315, (double)actual)); } [Test] public void Yearfrac_2_base4() { - Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",4)"); + var actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",4)"); Assert.IsTrue(XLHelper.AreEqual(5.24722222222222, (double)actual)); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/FormulaCachingTests.cs b/ClosedXML.Tests/Excel/CalcEngine/FormulaCachingTests.cs index 263ce3e09..2f23f0a27 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/FormulaCachingTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/FormulaCachingTests.cs @@ -11,192 +11,172 @@ public class FormulaCachingTests [Test] public void NewWorkbookDoesNotNeedRecalculation() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var cell = sheet.Cell(1, 1); + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var cell = sheet.Cell(1, 1); - Assert.AreEqual(0, wb.RecalculationCounter); - Assert.IsFalse(cell.NeedsRecalculation); - } + Assert.AreEqual(0, wb.RecalculationCounter); + Assert.IsFalse(cell.NeedsRecalculation); } [Test] public void EditCellCausesCounterIncreasing() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var cell = sheet.Cell(1, 1); - cell.Value = "1234567"; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var cell = sheet.Cell(1, 1); + cell.Value = "1234567"; - Assert.Greater(wb.RecalculationCounter, 0); - } + Assert.Greater(wb.RecalculationCounter, 0); } [Test] public void StaticCellDoesNotNeedRecalculation() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var cell = sheet.Cell(1, 1); - cell.Value = "1234567"; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var cell = sheet.Cell(1, 1); + cell.Value = "1234567"; - Assert.IsFalse(cell.NeedsRecalculation); - } + Assert.IsFalse(cell.NeedsRecalculation); } [Test] public void EditCellInvalidatesDependentCells() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var cell = sheet.Cell(1, 1); - var dependentCell = sheet.Cell(2, 1); - dependentCell.FormulaA1 = "=A1"; - var _ = dependentCell.Value; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var cell = sheet.Cell(1, 1); + var dependentCell = sheet.Cell(2, 1); + dependentCell.FormulaA1 = "=A1"; + _ = dependentCell.Value; - cell.Value = "1234567"; + cell.Value = "1234567"; - Assert.IsTrue(dependentCell.NeedsRecalculation); - } + Assert.IsTrue(dependentCell.NeedsRecalculation); } [Test] public void EditFormulaA1InvalidatesDependentCells() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=SUM(A1:A3)"; - a1.Value = 15; - - var res1 = a4.Value; - a2.FormulaA1 = "=A1*20"; - var res2 = a4.Value; - - Assert.AreEqual(15 + 150 + 1500, res1); - Assert.AreEqual(15 + 300 + 3000, res2); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=SUM(A1:A3)"; + a1.Value = 15; + + var res1 = a4.Value; + a2.FormulaA1 = "=A1*20"; + var res2 = a4.Value; + + Assert.AreEqual(15 + 150 + 1500, res1); + Assert.AreEqual(15 + 300 + 3000, res2); } [Test] public void EditFormulaR1C1InvalidatesDependentCells() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=SUM(A1:A3)"; - a1.Value = 15; - - var res1 = a4.Value; - a2.FormulaR1C1 = "=R[-1]C*2"; - var res2 = a4.Value; - - Assert.AreEqual(15 + 150 + 1500, res1); - Assert.AreEqual(15 + 30 + 300, res2); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=SUM(A1:A3)"; + a1.Value = 15; + + var res1 = a4.Value; + a2.FormulaR1C1 = "=R[-1]C*2"; + var res2 = a4.Value; + + Assert.AreEqual(15 + 150 + 1500, res1); + Assert.AreEqual(15 + 30 + 300, res2); } [Test] public void InsertRowInvalidatesValues() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a4 = sheet.Cell("A4"); - a4.FormulaA1 = "=COUNTBLANK(A1:A3)"; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a4 = sheet.Cell("A4"); + a4.FormulaA1 = "=COUNTBLANK(A1:A3)"; - var res1 = a4.Value; - sheet.Row(2).InsertRowsAbove(2); - var res2 = a4.Value; + var res1 = a4.Value; + sheet.Row(2).InsertRowsAbove(2); + var res2 = a4.Value; - Assert.AreEqual(3, res1); - Assert.AreEqual(5, res2); - } + Assert.AreEqual(3, res1); + Assert.AreEqual(5, res2); } [Test] public void DeleteRowInvalidatesValues() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a4 = sheet.Cell("A4"); - a4.FormulaA1 = "=COUNTBLANK(A1:A3)"; + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a4 = sheet.Cell("A4"); + a4.FormulaA1 = "=COUNTBLANK(A1:A3)"; - var res1 = a4.Value; - sheet.Row(2).Delete(); - var res2 = a4.Value; + var res1 = a4.Value; + sheet.Row(2).Delete(); + var res2 = a4.Value; - Assert.AreEqual(3, res1); - Assert.AreEqual(2, res2); - } + Assert.AreEqual(3, res1); + Assert.AreEqual(2, res2); } [Test] public void ChainedCalculationPreservesIntermediateValues() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=SUM(A1:A3)"; - - a1.Value = 15; - var res = a4.Value; - - Assert.AreEqual(15 + 150 + 1500, res); - Assert.IsFalse(a4.NeedsRecalculation); - Assert.IsFalse(a3.NeedsRecalculation); - Assert.IsFalse(a2.NeedsRecalculation); - Assert.AreEqual(150, a2.CachedValue); - Assert.AreEqual(1500, a3.CachedValue); - Assert.AreEqual(15 + 150 + 1500, a4.CachedValue); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=SUM(A1:A3)"; + + a1.Value = 15; + var res = a4.Value; + + Assert.AreEqual(15 + 150 + 1500, res); + Assert.IsFalse(a4.NeedsRecalculation); + Assert.IsFalse(a3.NeedsRecalculation); + Assert.IsFalse(a2.NeedsRecalculation); + Assert.AreEqual(150, a2.CachedValue); + Assert.AreEqual(1500, a3.CachedValue); + Assert.AreEqual(15 + 150 + 1500, a4.CachedValue); } [Test] public void EditingAffectsDependentCells() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=SUM(A1:A3)"; - a1.Value = 15; - - var res1 = a4.Value; - a1.Value = 20; - var res2 = a4.Value; - - Assert.AreEqual(15 + 150 + 1500, res1); - Assert.AreEqual(20 + 200 + 2000, res2); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=SUM(A1:A3)"; + a1.Value = 15; + + var res1 = a4.Value; + a1.Value = 20; + var res2 = a4.Value; + + Assert.AreEqual(15 + 150 + 1500, res1); + Assert.AreEqual(20 + 200 + 2000, res2); } [Test] @@ -207,185 +187,171 @@ public void EditingAffectsDependentCells() [TestCase("C2", new string[] { "C5" })] public void EditingDoesNotAffectNonDependingCells(string changedCell, string[] affectedCells) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + sheet.Cell("A2").FormulaA1 = "A1+1"; + sheet.Cell("A3").FormulaA1 = "SUM(A1:A2)"; + sheet.Cell("A4").FormulaA1 = "SUM(A1:A3)"; + sheet.Cell("B2").FormulaA1 = "B1+1"; + sheet.Cell("B3").FormulaA1 = "SUM(B1:B2)"; + sheet.Cell("B4").FormulaA1 = "SUM(B1:B3)"; + sheet.Cell("C1").FormulaA1 = "SUM(A1:B1)"; + sheet.Cell("C2").FormulaA1 = "SUM(A2:B2)"; + sheet.Cell("C3").FormulaA1 = "SUM(A3:B3)"; + sheet.Cell("C5").FormulaA1 = "SUM($A$1:$C$4)"; + sheet.RecalculateAllFormulas(); + var allCells = sheet.CellsUsed(); + + sheet.Cell(changedCell).Value = 100; + var modifiedCells = allCells.Where(cell => cell.NeedsRecalculation); + + Assert.AreEqual(affectedCells?.Length, modifiedCells.Count()); + foreach (var cellAddress in affectedCells) { - var sheet = wb.Worksheets.Add("TestSheet"); - sheet.Cell("A2").FormulaA1 = "A1+1"; - sheet.Cell("A3").FormulaA1 = "SUM(A1:A2)"; - sheet.Cell("A4").FormulaA1 = "SUM(A1:A3)"; - sheet.Cell("B2").FormulaA1 = "B1+1"; - sheet.Cell("B3").FormulaA1 = "SUM(B1:B2)"; - sheet.Cell("B4").FormulaA1 = "SUM(B1:B3)"; - sheet.Cell("C1").FormulaA1 = "SUM(A1:B1)"; - sheet.Cell("C2").FormulaA1 = "SUM(A2:B2)"; - sheet.Cell("C3").FormulaA1 = "SUM(A3:B3)"; - sheet.Cell("C5").FormulaA1 = "SUM($A$1:$C$4)"; - sheet.RecalculateAllFormulas(); - var allCells = sheet.CellsUsed(); - - sheet.Cell(changedCell).Value = 100; - var modifiedCells = allCells.Where(cell => cell.NeedsRecalculation); - - Assert.AreEqual(affectedCells.Length, modifiedCells.Count()); - foreach (var cellAddress in affectedCells) - { - Assert.IsTrue(modifiedCells.Any(cell => cell.Address.ToString() == cellAddress), - string.Format("Cell {0} is expected to need recalculation, but it does not", cellAddress)); - } + Assert.IsTrue(modifiedCells.Any(cell => cell.Address.ToString() == cellAddress), + string.Format("Cell {0} is expected to need recalculation, but it does not", cellAddress)); } } [Test] public void CircularReferenceFailsCalculating() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=A3*10"; - a1.FormulaA1 = "A2+A3+A4"; - - var getValueA1 = new TestDelegate(() => { var v = a1.Value; }); - var getValueA2 = new TestDelegate(() => { var v = a2.Value; }); - var getValueA3 = new TestDelegate(() => { var v = a3.Value; }); - var getValueA4 = new TestDelegate(() => { var v = a4.Value; }); - - Assert.Throws(typeof(InvalidOperationException), getValueA1); - Assert.Throws(typeof(InvalidOperationException), getValueA2); - Assert.Throws(typeof(InvalidOperationException), getValueA3); - Assert.Throws(typeof(InvalidOperationException), getValueA4); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=A3*10"; + a1.FormulaA1 = "A2+A3+A4"; + + var getValueA1 = new TestDelegate(() => { _ = a1.Value; }); + var getValueA2 = new TestDelegate(() => { _ = a2.Value; }); + var getValueA3 = new TestDelegate(() => { _ = a3.Value; }); + var getValueA4 = new TestDelegate(() => { _ = a4.Value; }); + + Assert.Throws(typeof(InvalidOperationException), getValueA1); + Assert.Throws(typeof(InvalidOperationException), getValueA2); + Assert.Throws(typeof(InvalidOperationException), getValueA3); + Assert.Throws(typeof(InvalidOperationException), getValueA4); } [Test] public void CircularReferenceRecalculationNeededDoesNotFail() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var a1 = sheet.Cell("A1"); - var a2 = sheet.Cell("A2"); - var a3 = sheet.Cell("A3"); - var a4 = sheet.Cell("A4"); - - a2.FormulaA1 = "=A1*10"; - a3.FormulaA1 = "=A2*10"; - a4.FormulaA1 = "=A3*10"; - var _ = a4.Value; - a1.FormulaA1 = "=SUM(A2:A4)"; - - var recalcNeededA1 = a1.NeedsRecalculation; - var recalcNeededA2 = a2.NeedsRecalculation; - var recalcNeededA3 = a3.NeedsRecalculation; - var recalcNeededA4 = a4.NeedsRecalculation; - - Assert.IsTrue(recalcNeededA1); - Assert.IsTrue(recalcNeededA2); - Assert.IsTrue(recalcNeededA3); - Assert.IsTrue(recalcNeededA4); - } + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var a1 = sheet.Cell("A1"); + var a2 = sheet.Cell("A2"); + var a3 = sheet.Cell("A3"); + var a4 = sheet.Cell("A4"); + + a2.FormulaA1 = "=A1*10"; + a3.FormulaA1 = "=A2*10"; + a4.FormulaA1 = "=A3*10"; + _ = a4.Value; + a1.FormulaA1 = "=SUM(A2:A4)"; + + var recalcNeededA1 = a1.NeedsRecalculation; + var recalcNeededA2 = a2.NeedsRecalculation; + var recalcNeededA3 = a3.NeedsRecalculation; + var recalcNeededA4 = a4.NeedsRecalculation; + + Assert.IsTrue(recalcNeededA1); + Assert.IsTrue(recalcNeededA2); + Assert.IsTrue(recalcNeededA3); + Assert.IsTrue(recalcNeededA4); } [Test] public void DeleteWorksheetInvalidatesValues() { - using (var wb = new XLWorkbook()) - { - var sheet1 = wb.Worksheets.Add("Sheet1"); - var sheet2 = wb.Worksheets.Add("Sheet2"); - var sheet1_a1 = sheet1.Cell("A1"); - var sheet2_a1 = sheet2.Cell("A1"); - sheet1_a1.FormulaA1 = "Sheet2!A1"; - sheet2_a1.Value = "TestValue"; - - var val1 = sheet1_a1.Value; - sheet2.Delete(); - var getValue = new TestDelegate(() => { var val2 = sheet1_a1.Value; }); - - Assert.AreEqual("TestValue", val1.ToString()); - Assert.Throws(typeof(ArgumentOutOfRangeException), getValue); - } + using var wb = new XLWorkbook(); + var sheet1 = wb.Worksheets.Add("Sheet1"); + var sheet2 = wb.Worksheets.Add("Sheet2"); + var sheet1_a1 = sheet1.Cell("A1"); + var sheet2_a1 = sheet2.Cell("A1"); + sheet1_a1.FormulaA1 = "Sheet2!A1"; + sheet2_a1.Value = "TestValue"; + + var val1 = sheet1_a1.Value; + sheet2.Delete(); + var getValue = new TestDelegate(() => { _ = sheet1_a1.Value; }); + + Assert.AreEqual("TestValue", val1.ToString()); + Assert.Throws(typeof(ArgumentOutOfRangeException), getValue); } [Test] public void TestValueCellsCachedValue() { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - var cell = sheet.Cell(1, 1); + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); + var cell = sheet.Cell(1, 1); - var date = new DateTime(2018, 4, 19); ; - cell.Value = date; + var date = new DateTime(2018, 4, 19); + cell.Value = date; - Assert.AreEqual(XLDataType.DateTime, cell.DataType); - Assert.AreEqual(date, cell.CachedValue); + Assert.AreEqual(XLDataType.DateTime, cell.DataType); + Assert.AreEqual(date, cell.CachedValue); - cell.DataType = XLDataType.Number; + cell.DataType = XLDataType.Number; - Assert.AreEqual(XLDataType.Number, cell.DataType); - Assert.AreEqual(date.ToOADate(), cell.CachedValue); - } + Assert.AreEqual(XLDataType.Number, cell.DataType); + Assert.AreEqual(date.ToOADate(), cell.CachedValue); } [Test] public void CachedValueToExternalWorkbook() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\ExternalLinks\WorkbookWithExternalLink.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - var cell = ws.Cell("B2"); - Assert.IsFalse(cell.NeedsRecalculation); - Assert.IsTrue(cell.HasFormula); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\ExternalLinks\WorkbookWithExternalLink.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + var cell = ws.Cell("B2"); + Assert.IsFalse(cell.NeedsRecalculation); + Assert.IsTrue(cell.HasFormula); - // This will fail when we start supporting external links - Assert.IsTrue(cell.FormulaA1.StartsWith("[1]")); + // This will fail when we start supporting external links + Assert.IsTrue(cell.FormulaA1.StartsWith("[1]")); - Assert.AreEqual("hello world", cell.CachedValue); - Assert.AreEqual("hello world", cell.Value); + Assert.AreEqual("hello world", cell.CachedValue); + Assert.AreEqual("hello world", cell.Value); - Assert.AreEqual(11, ws.Evaluate("LEN(B2)")); + Assert.AreEqual(11, ws.Evaluate("LEN(B2)")); - Assert.Throws(() => wb.RecalculateAllFormulas()); - } + Assert.Throws(() => wb.RecalculateAllFormulas()); } [Test] public void ChangingDataTypeChangesCachedValue() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Test"); - ws.Cell(1, 1).Value = new DateTime(2019, 1, 1, 14, 0, 0); - ws.Cell(1, 2).Value = new DateTime(2019, 1, 1, 17, 45, 0); - var cell = ws.Cell(1, 3); - cell.FormulaA1 = "=B1-A1"; - cell.Style.DateFormat.Format = "hh:mm"; - - Assert.IsNull(cell.CachedValue); - - double value = (double)cell.Value; - Assert.AreEqual(value, cell.CachedValue); - - cell.DataType = XLDataType.DateTime; - Assert.AreEqual(DateTime.FromOADate(value), cell.CachedValue); - Assert.AreEqual("03:45", cell.GetFormattedString()); - - cell.DataType = XLDataType.Number; - Assert.AreEqual(value, (double)cell.CachedValue, 1e-10); - Assert.AreEqual("0.15625", cell.GetFormattedString()); - - cell.DataType = XLDataType.TimeSpan; - Assert.AreEqual(TimeSpan.FromDays(value), (TimeSpan)cell.CachedValue); - Assert.AreEqual("03:45:00", cell.GetFormattedString()); // I think the seconds in this string is due to a shortcoming in the ExcelNumberFormat library - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Test"); + ws.Cell(1, 1).Value = new DateTime(2019, 1, 1, 14, 0, 0); + ws.Cell(1, 2).Value = new DateTime(2019, 1, 1, 17, 45, 0); + var cell = ws.Cell(1, 3); + cell.FormulaA1 = "=B1-A1"; + cell.Style.DateFormat.Format = "hh:mm"; + + Assert.IsNull(cell.CachedValue); + + var value = (double)cell.Value; + Assert.AreEqual(value, cell.CachedValue); + + cell.DataType = XLDataType.DateTime; + Assert.AreEqual(DateTime.FromOADate(value), cell.CachedValue); + Assert.AreEqual("03:45", cell.GetFormattedString()); + + cell.DataType = XLDataType.Number; + Assert.AreEqual(value, (double)cell.CachedValue, 1e-10); + Assert.AreEqual("03:45", cell.GetFormattedString()); + + cell.DataType = XLDataType.TimeSpan; + Assert.AreEqual(TimeSpan.FromDays(value), (TimeSpan)cell.CachedValue); + Assert.AreEqual("03:45:00", cell.GetFormattedString()); // I think the seconds in this string is due to a shortcoming in the ExcelNumberFormat library } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/FunctionsTests.cs b/ClosedXML.Tests/Excel/CalcEngine/FunctionsTests.cs index adacedda9..bb3f9e06d 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/FunctionsTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/FunctionsTests.cs @@ -17,7 +17,7 @@ public void Init() [Test] public void Asc() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Asc(""Text"")"); Assert.AreEqual("Text", actual); @@ -26,33 +26,33 @@ public void Asc() [Test] public void Clean() { - Object actual; + object actual; - actual = XLWorkbook.EvaluateExpr(String.Format(@"Clean(""A{0}B"")", Environment.NewLine)); + actual = XLWorkbook.EvaluateExpr(string.Format(@"Clean(""A{0}B"")", XLConstants.NewLine)); Assert.AreEqual("AB", actual); } [Test] public void Combin() { - object actual1 = XLWorkbook.EvaluateExpr("Combin(200, 2)"); + var actual1 = XLWorkbook.EvaluateExpr("Combin(200, 2)"); Assert.AreEqual(19900.0, actual1); - object actual2 = XLWorkbook.EvaluateExpr("Combin(20.1, 2.9)"); + var actual2 = XLWorkbook.EvaluateExpr("Combin(20.1, 2.9)"); Assert.AreEqual(190.0, actual2); } [Test] public void Degrees() { - object actual1 = XLWorkbook.EvaluateExpr("Degrees(180)"); + var actual1 = XLWorkbook.EvaluateExpr("Degrees(180)"); Assert.IsTrue(Math.PI - (double)actual1 < XLHelper.Epsilon); } [Test] public void Dollar() { - object actual = XLWorkbook.EvaluateExpr("Dollar(12345.123)"); + var actual = XLWorkbook.EvaluateExpr("Dollar(12345.123)"); Assert.AreEqual(TestHelper.CurrencySymbol + "12,345.12", actual); actual = XLWorkbook.EvaluateExpr("Dollar(12345.123, 1)"); @@ -62,7 +62,7 @@ public void Dollar() [Test] public void Even() { - object actual = XLWorkbook.EvaluateExpr("Even(3)"); + var actual = XLWorkbook.EvaluateExpr("Even(3)"); Assert.AreEqual(4, actual); actual = XLWorkbook.EvaluateExpr("Even(2)"); @@ -87,7 +87,7 @@ public void Even() [Test] public void Exact() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr("Exact(\"A\", \"A\")"); Assert.AreEqual(true, actual); @@ -99,23 +99,23 @@ public void Exact() [Test] public void Fact() { - object actual = XLWorkbook.EvaluateExpr("Fact(5.9)"); + var actual = XLWorkbook.EvaluateExpr("Fact(5.9)"); Assert.AreEqual(120.0, actual); } [Test] public void FactDouble() { - object actual1 = XLWorkbook.EvaluateExpr("FactDouble(6)"); + var actual1 = XLWorkbook.EvaluateExpr("FactDouble(6)"); Assert.AreEqual(48.0, actual1); - object actual2 = XLWorkbook.EvaluateExpr("FactDouble(7)"); + var actual2 = XLWorkbook.EvaluateExpr("FactDouble(7)"); Assert.AreEqual(105.0, actual2); } [Test] public void Fixed() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr("Fixed(12345.123)"); Assert.AreEqual("12,345.12", actual); @@ -130,55 +130,56 @@ public void Fixed() [Test] public void Formula_from_another_sheet() { - var wb = new XLWorkbook(); - IXLWorksheet ws1 = wb.AddWorksheet("ws1"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("ws1"); ws1.FirstCell().SetValue(1).CellRight().SetFormulaA1("A1 + 1"); - IXLWorksheet ws2 = wb.AddWorksheet("ws2"); + var ws2 = wb.AddWorksheet("ws2"); ws2.FirstCell().SetFormulaA1("ws1!B1 + 1"); - object v = ws2.FirstCell().Value; + var v = ws2.FirstCell().Value; Assert.AreEqual(3.0, v); } [Test] public void Gcd() { - object actual = XLWorkbook.EvaluateExpr("Gcd(24, 36)"); + var actual = XLWorkbook.EvaluateExpr("Gcd(24, 36)"); Assert.AreEqual(12, actual); - object actual1 = XLWorkbook.EvaluateExpr("Gcd(5, 0)"); + var actual1 = XLWorkbook.EvaluateExpr("Gcd(5, 0)"); Assert.AreEqual(5, actual1); - object actual2 = XLWorkbook.EvaluateExpr("Gcd(0, 5)"); + var actual2 = XLWorkbook.EvaluateExpr("Gcd(0, 5)"); Assert.AreEqual(5, actual2); - object actual3 = XLWorkbook.EvaluateExpr("Gcd(240, 360, 30)"); + var actual3 = XLWorkbook.EvaluateExpr("Gcd(240, 360, 30)"); Assert.AreEqual(30, actual3); } [Test] public void Lcm() { - object actual = XLWorkbook.EvaluateExpr("Lcm(24, 36)"); + var actual = XLWorkbook.EvaluateExpr("Lcm(24, 36)"); Assert.AreEqual(72, actual); - object actual1 = XLWorkbook.EvaluateExpr("Lcm(5, 0)"); + var actual1 = XLWorkbook.EvaluateExpr("Lcm(5, 0)"); Assert.AreEqual(0, actual1); - object actual2 = XLWorkbook.EvaluateExpr("Lcm(0, 5)"); + var actual2 = XLWorkbook.EvaluateExpr("Lcm(0, 5)"); Assert.AreEqual(0, actual2); - object actual3 = XLWorkbook.EvaluateExpr("Lcm(240, 360, 30)"); + var actual3 = XLWorkbook.EvaluateExpr("Lcm(240, 360, 30)"); Assert.AreEqual(720, actual3); } [Test] public void MDetem() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Cell("A1").SetValue(2).CellRight().SetValue(4); ws.Cell("A2").SetValue(3).CellRight().SetValue(5); - Object actual; + object actual; ws.Cell("A5").FormulaA1 = "MDeterm(A1:B2)"; actual = ws.Cell("A5").Value; @@ -199,12 +200,13 @@ public void MDetem() [Test] public void MInverse() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Cell("A1").SetValue(1).CellRight().SetValue(2).CellRight().SetValue(1); ws.Cell("A2").SetValue(3).CellRight().SetValue(4).CellRight().SetValue(-1); ws.Cell("A3").SetValue(0).CellRight().SetValue(2).CellRight().SetValue(0); - Object actual; + object actual; ws.Cell("A5").FormulaA1 = "MInverse(A1:C3)"; actual = ws.Cell("A5").Value; @@ -225,13 +227,13 @@ public void MInverse() [Test] public void MMult() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Cell("A1").SetValue(2).CellRight().SetValue(4); ws.Cell("A2").SetValue(3).CellRight().SetValue(5); ws.Cell("A3").SetValue(2).CellRight().SetValue(4); ws.Cell("A4").SetValue(3).CellRight().SetValue(5); - Object actual; + object actual; ws.Cell("A5").FormulaA1 = "MMult(A1:B2, A3:B4)"; actual = ws.Cell("A5").Value; @@ -252,42 +254,42 @@ public void MMult() [Test] public void Mod() { - object actual = XLWorkbook.EvaluateExpr("Mod(3, 2)"); + var actual = XLWorkbook.EvaluateExpr("Mod(3, 2)"); Assert.AreEqual(1, actual); - object actual1 = XLWorkbook.EvaluateExpr("Mod(-3, 2)"); + var actual1 = XLWorkbook.EvaluateExpr("Mod(-3, 2)"); Assert.AreEqual(1, actual1); - object actual2 = XLWorkbook.EvaluateExpr("Mod(3, -2)"); + var actual2 = XLWorkbook.EvaluateExpr("Mod(3, -2)"); Assert.AreEqual(-1, actual2); - object actual3 = XLWorkbook.EvaluateExpr("Mod(-3, -2)"); + var actual3 = XLWorkbook.EvaluateExpr("Mod(-3, -2)"); Assert.AreEqual(-1, actual3); } [Test] public void Multinomial() { - object actual = XLWorkbook.EvaluateExpr("Multinomial(2,3,4)"); + var actual = XLWorkbook.EvaluateExpr("Multinomial(2,3,4)"); Assert.AreEqual(1260.0, actual); } [Test] public void Odd() { - object actual = XLWorkbook.EvaluateExpr("Odd(1.5)"); + var actual = XLWorkbook.EvaluateExpr("Odd(1.5)"); Assert.AreEqual(3, actual); - object actual1 = XLWorkbook.EvaluateExpr("Odd(3)"); + var actual1 = XLWorkbook.EvaluateExpr("Odd(3)"); Assert.AreEqual(3, actual1); - object actual2 = XLWorkbook.EvaluateExpr("Odd(2)"); + var actual2 = XLWorkbook.EvaluateExpr("Odd(2)"); Assert.AreEqual(3, actual2); - object actual3 = XLWorkbook.EvaluateExpr("Odd(-1)"); + var actual3 = XLWorkbook.EvaluateExpr("Odd(-1)"); Assert.AreEqual(-1, actual3); - object actual4 = XLWorkbook.EvaluateExpr("Odd(-2)"); + var actual4 = XLWorkbook.EvaluateExpr("Odd(-2)"); Assert.AreEqual(-3, actual4); actual = XLWorkbook.EvaluateExpr("Odd(0)"); @@ -297,14 +299,14 @@ public void Odd() [Test] public void Product() { - object actual = XLWorkbook.EvaluateExpr("Product(2,3,4)"); + var actual = XLWorkbook.EvaluateExpr("Product(2,3,4)"); Assert.AreEqual(24.0, actual); } [Test] public void Quotient() { - object actual = XLWorkbook.EvaluateExpr("Quotient(5,2)"); + var actual = XLWorkbook.EvaluateExpr("Quotient(5,2)"); Assert.AreEqual(2, actual); actual = XLWorkbook.EvaluateExpr("Quotient(4.5,3.1)"); @@ -317,14 +319,14 @@ public void Quotient() [Test] public void Radians() { - object actual = XLWorkbook.EvaluateExpr("Radians(270)"); + var actual = XLWorkbook.EvaluateExpr("Radians(270)"); Assert.IsTrue(Math.Abs(4.71238898038469 - (double)actual) < XLHelper.Epsilon); } [Test] public void Roman() { - object actual = XLWorkbook.EvaluateExpr("Roman(3046, 1)"); + var actual = XLWorkbook.EvaluateExpr("Roman(3046, 1)"); Assert.AreEqual("MMMXLVI", actual); actual = XLWorkbook.EvaluateExpr("Roman(270)"); @@ -337,7 +339,7 @@ public void Roman() [Test] public void Round() { - object actual = XLWorkbook.EvaluateExpr("Round(2.15, 1)"); + var actual = XLWorkbook.EvaluateExpr("Round(2.15, 1)"); Assert.AreEqual(2.2, actual); actual = XLWorkbook.EvaluateExpr("Round(2.149, 1)"); @@ -368,7 +370,7 @@ public void Round() [Test] public void RoundDown() { - object actual = XLWorkbook.EvaluateExpr("RoundDown(3.2, 0)"); + var actual = XLWorkbook.EvaluateExpr("RoundDown(3.2, 0)"); Assert.AreEqual(3.0, actual); actual = XLWorkbook.EvaluateExpr("RoundDown(76.9, 0)"); @@ -390,7 +392,7 @@ public void RoundDown() [Test] public void RoundUp() { - object actual = XLWorkbook.EvaluateExpr("RoundUp(3.2, 0)"); + var actual = XLWorkbook.EvaluateExpr("RoundUp(3.2, 0)"); Assert.AreEqual(4.0, actual); actual = XLWorkbook.EvaluateExpr("RoundUp(76.9, 0)"); @@ -412,11 +414,11 @@ public void RoundUp() [Test] public void SeriesSum() { - object actual = XLWorkbook.EvaluateExpr("SERIESSUM(2,3,4,5)"); + var actual = XLWorkbook.EvaluateExpr("SERIESSUM(2,3,4,5)"); Assert.AreEqual(40.0, actual); - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A2").FormulaA1 = "PI()/4"; ws.Cell("A3").Value = 1; ws.Cell("A4").FormulaA1 = "-1/FACT(2)"; @@ -430,7 +432,7 @@ public void SeriesSum() [Test] public void SqrtPi() { - object actual = XLWorkbook.EvaluateExpr("SqrtPi(1)"); + var actual = XLWorkbook.EvaluateExpr("SqrtPi(1)"); Assert.IsTrue(Math.Abs(1.7724538509055159 - (double)actual) < XLHelper.Epsilon); actual = XLWorkbook.EvaluateExpr("SqrtPi(2)"); @@ -440,7 +442,7 @@ public void SqrtPi() [Test] public void SubtotalAverage() { - object actual = XLWorkbook.EvaluateExpr("Subtotal(1,2,3)"); + var actual = XLWorkbook.EvaluateExpr("Subtotal(1,2,3)"); Assert.AreEqual(2.5, actual); actual = XLWorkbook.EvaluateExpr(@"Subtotal(1,""A"",3, 2)"); @@ -450,7 +452,7 @@ public void SubtotalAverage() [Test] public void SubtotalCount() { - object actual = XLWorkbook.EvaluateExpr("Subtotal(2,2,3)"); + var actual = XLWorkbook.EvaluateExpr("Subtotal(2,2,3)"); Assert.AreEqual(2, actual); actual = XLWorkbook.EvaluateExpr(@"Subtotal(2,""A"",3)"); @@ -460,7 +462,7 @@ public void SubtotalCount() [Test] public void SubtotalCountA() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr("Subtotal(3,2,3)"); Assert.AreEqual(2.0, actual); @@ -472,7 +474,7 @@ public void SubtotalCountA() [Test] public void SubtotalMax() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(4,2,3,""A"")"); Assert.AreEqual(3.0, actual); @@ -481,7 +483,7 @@ public void SubtotalMax() [Test] public void SubtotalMin() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(5,2,3,""A"")"); Assert.AreEqual(2.0, actual); @@ -490,7 +492,7 @@ public void SubtotalMin() [Test] public void SubtotalProduct() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(6,2,3,""A"")"); Assert.AreEqual(6.0, actual); @@ -499,7 +501,7 @@ public void SubtotalProduct() [Test] public void SubtotalStDev() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(7,2,3,""A"")"); Assert.IsTrue(Math.Abs(0.70710678118654757 - (double)actual) < XLHelper.Epsilon); @@ -508,7 +510,7 @@ public void SubtotalStDev() [Test] public void SubtotalStDevP() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(8,2,3,""A"")"); Assert.AreEqual(0.5, actual); @@ -517,7 +519,7 @@ public void SubtotalStDevP() [Test] public void SubtotalSum() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(9,2,3,""A"")"); Assert.AreEqual(5.0, actual); @@ -526,7 +528,7 @@ public void SubtotalSum() [Test] public void SubtotalVar() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(10,2,3,""A"")"); Assert.IsTrue(Math.Abs(0.5 - (double)actual) < XLHelper.Epsilon); @@ -535,7 +537,7 @@ public void SubtotalVar() [Test] public void SubtotalVarP() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Subtotal(11,2,3,""A"")"); Assert.AreEqual(0.25, actual); @@ -544,7 +546,7 @@ public void SubtotalVarP() [Test] public void SubtotalCalc() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); ws.NamedRanges.Add("subtotalrange", "A37:A38"); @@ -612,8 +614,9 @@ public void SubtotalCalc() [Test] public void Sum() { - IXLCell cell = new XLWorkbook().AddWorksheet("Sheet1").FirstCell(); - IXLCell fCell = cell.SetValue(1).CellBelow().SetValue(2).CellBelow(); + using var xLWorkbook = new XLWorkbook(); + var cell = xLWorkbook.AddWorksheet("Sheet1").FirstCell(); + var fCell = cell.SetValue(1).CellBelow().SetValue(2).CellBelow(); fCell.FormulaA1 = "sum(A1:A2)"; Assert.AreEqual(3.0, fCell.Value); @@ -622,23 +625,21 @@ public void Sum() [Test] public void SumDateTimeAndNumber() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = 1; - ws.Cell("A2").Value = new DateTime(2018, 1, 1); - Assert.AreEqual(43102, ws.Evaluate("SUM(A1:A2)")); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = 1; + ws.Cell("A2").Value = new DateTime(2018, 1, 1); + Assert.AreEqual(43102, ws.Evaluate("SUM(A1:A2)")); - ws.Cell("A1").Value = 2; - ws.Cell("A2").FormulaA1 = "DATE(2018,1,1)"; - Assert.AreEqual(43103, ws.Evaluate("SUM(A1:A2)")); - } + ws.Cell("A1").Value = 2; + ws.Cell("A2").FormulaA1 = "DATE(2018,1,1)"; + Assert.AreEqual(43103, ws.Evaluate("SUM(A1:A2)")); } [Test] public void SumSq() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"SumSq(3,4)"); Assert.AreEqual(25.0, actual); @@ -647,8 +648,8 @@ public void SumSq() [Test] public void TextConcat() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = 1; ws.Cell("A2").Value = 1; ws.Cell("B1").Value = 1; @@ -656,7 +657,7 @@ public void TextConcat() ws.Cell("C1").FormulaA1 = "\"The total value is: \" & SUM(A1:B2)"; - object r = ws.Cell("C1").Value; + var r = ws.Cell("C1").Value; Assert.AreEqual("The total value is: 4", r.ToString()); } @@ -674,7 +675,7 @@ public void Trim() public void TestEmptyTallyOperations() { //In these test no values have been set - XLWorkbook wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.Worksheets.Add("TallyTests"); var cell = wb.Worksheet(1).Cell(1, 1).SetFormulaA1("=MAX(D1,D2)"); Assert.AreEqual(0, cell.Value); @@ -688,21 +689,19 @@ public void TestEmptyTallyOperations() [Test] public void TestOmittedParameters() { - using (var wb = new XLWorkbook()) - { - object value; - value = wb.Evaluate("=IF(TRUE,1)"); - Assert.AreEqual(1, value); + using var wb = new XLWorkbook(); + object value; + value = wb.Evaluate("=IF(TRUE,1)"); + Assert.AreEqual(1, value); - value = wb.Evaluate("=IF(TRUE,1,)"); - Assert.AreEqual(1, value); + value = wb.Evaluate("=IF(TRUE,1,)"); + Assert.AreEqual(1, value); - value = wb.Evaluate("=IF(FALSE,1,)"); - Assert.AreEqual(false, value); + value = wb.Evaluate("=IF(FALSE,1,)"); + Assert.AreEqual(false, value); - value = wb.Evaluate("=IF(FALSE,,2)"); - Assert.AreEqual(2, value); - } + value = wb.Evaluate("=IF(FALSE,,2)"); + Assert.AreEqual(2, value); } [Test] @@ -751,4 +750,4 @@ public void TestStringSubExpression(string formula, object expectedResult) Assert.AreEqual(expectedResult, actual); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/InformationTests.cs b/ClosedXML.Tests/Excel/CalcEngine/InformationTests.cs index 5686e0598..8877735f3 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/InformationTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/InformationTests.cs @@ -20,62 +20,52 @@ public void SetCultureInfo() [Test] public void IsBlank_MultipleAllEmpty_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - var actual = ws.Evaluate("=IsBlank(A1:A3)"); - Assert.AreEqual(true, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + var actual = ws.Evaluate("=IsBlank(A1:A3)"); + Assert.AreEqual(true, actual); } [Test] public void IsBlank_MultipleAllFill_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "1"; - ws.Cell("A2").Value = "1"; - ws.Cell("A3").Value = "1"; - var actual = ws.Evaluate("=IsBlank(A1:A3)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "1"; + ws.Cell("A2").Value = "1"; + ws.Cell("A3").Value = "1"; + var actual = ws.Evaluate("=IsBlank(A1:A3)"); + Assert.AreEqual(false, actual); } [Test] public void IsBlank_MultipleMixedFill_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "1"; - ws.Cell("A3").Value = "1"; - var actual = ws.Evaluate("=IsBlank(A1:A3)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "1"; + ws.Cell("A3").Value = "1"; + var actual = ws.Evaluate("=IsBlank(A1:A3)"); + Assert.AreEqual(false, actual); } [Test] public void IsBlank_Single_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = " "; - var actual = ws.Evaluate("=IsBlank(A1)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = " "; + var actual = ws.Evaluate("=IsBlank(A1)"); + Assert.AreEqual(false, actual); } [Test] public void IsBlank_Single_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - var actual = ws.Evaluate("=IsBlank(A1)"); - Assert.AreEqual(true, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + var actual = ws.Evaluate("=IsBlank(A1)"); + Assert.AreEqual(true, actual); } #endregion IsBlank Tests @@ -85,45 +75,41 @@ public void IsBlank_Single_true() [Test] public void IsEven_Single_False() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = 1; - ws.Cell("A2").Value = 1.2; - ws.Cell("A3").Value = 3; + ws.Cell("A1").Value = 1; + ws.Cell("A2").Value = 1.2; + ws.Cell("A3").Value = 3; - var actual = ws.Evaluate("=IsEven(A1)"); - Assert.AreEqual(false, actual); + var actual = ws.Evaluate("=IsEven(A1)"); + Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsEven(A2)"); - Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsEven(A2)"); + Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsEven(A3)"); - Assert.AreEqual(false, actual); - } + actual = ws.Evaluate("=IsEven(A3)"); + Assert.AreEqual(false, actual); } [Test] public void IsEven_Single_True() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = 4; - ws.Cell("A2").Value = 0.2; - ws.Cell("A3").Value = 12.2; + ws.Cell("A1").Value = 4; + ws.Cell("A2").Value = 0.2; + ws.Cell("A3").Value = 12.2; - var actual = ws.Evaluate("=IsEven(A1)"); - Assert.AreEqual(true, actual); + var actual = ws.Evaluate("=IsEven(A1)"); + Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsEven(A2)"); - Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsEven(A2)"); + Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsEven(A3)"); - Assert.AreEqual(true, actual); - } + actual = ws.Evaluate("=IsEven(A3)"); + Assert.AreEqual(true, actual); } #endregion IsEven Tests @@ -133,29 +119,25 @@ public void IsEven_Single_True() [Test] public void IsLogical_Simpe_False() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = 123; + ws.Cell("A1").Value = 123; - var actual = ws.Evaluate("=IsLogical(A1)"); - Assert.AreEqual(false, actual); - } + var actual = ws.Evaluate("=IsLogical(A1)"); + Assert.AreEqual(false, actual); } [Test] public void IsLogical_Simple_True() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = true; + ws.Cell("A1").Value = true; - var actual = ws.Evaluate("=IsLogical(A1)"); - Assert.AreEqual(true, actual); - } + var actual = ws.Evaluate("=IsLogical(A1)"); + Assert.AreEqual(true, actual); } #endregion IsLogical Tests @@ -176,41 +158,37 @@ public void IsNA() [Test] public void IsNotText_Simple_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "asd"; - var actual = ws.Evaluate("=IsNonText(A1)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "asd"; + var actual = ws.Evaluate("=IsNonText(A1)"); + Assert.AreEqual(false, actual); } [Test] public void IsNotText_Simple_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "123"; //Double Value - ws.Cell("A2").Value = DateTime.Now; //Date Value - ws.Cell("A3").Value = "12,235.5"; //Comma Formatting - ws.Cell("A4").Value = "$12,235.5"; //Currency Value - ws.Cell("A5").Value = true; //Bool Value - ws.Cell("A6").Value = "12%"; //Percentage Value - - var actual = ws.Evaluate("=IsNonText(A1)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNonText(A2)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNonText(A3)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNonText(A4)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNonText(A5)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNonText(A6)"); - Assert.AreEqual(true, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "123"; //Double Value + ws.Cell("A2").Value = DateTime.Now; //Date Value + ws.Cell("A3").Value = "12,235.5"; //Comma Formatting + ws.Cell("A4").Value = "$12,235.5"; //Currency Value + ws.Cell("A5").Value = true; //Bool Value + ws.Cell("A6").Value = "12%"; //Percentage Value + + var actual = ws.Evaluate("=IsNonText(A1)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNonText(A2)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNonText(A3)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNonText(A4)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNonText(A5)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNonText(A6)"); + Assert.AreEqual(true, actual); } #endregion IsNotText Tests @@ -220,42 +198,38 @@ public void IsNotText_Simple_true() [Test] public void IsNumber_Simple_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "asd"; //String Value - ws.Cell("A2").Value = true; //Bool Value - - var actual = ws.Evaluate("=IsNumber(A1)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsNumber(A2)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "asd"; //String Value + ws.Cell("A2").Value = true; //Bool Value + + var actual = ws.Evaluate("=IsNumber(A1)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsNumber(A2)"); + Assert.AreEqual(false, actual); } [Test] public void IsNumber_Simple_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "123"; //Double Value - ws.Cell("A2").Value = DateTime.Now; //Date Value - ws.Cell("A3").Value = "12,235.5"; //Coma Formatting - ws.Cell("A4").Value = "$12,235.5"; //Currency Value - ws.Cell("A5").Value = "12%"; //Percentage Value - - var actual = ws.Evaluate("=IsNumber(A1)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNumber(A2)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNumber(A3)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNumber(A4)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsNumber(A5)"); - Assert.AreEqual(true, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "123"; //Double Value + ws.Cell("A2").Value = DateTime.Now; //Date Value + ws.Cell("A3").Value = "12,235.5"; //Coma Formatting + ws.Cell("A4").Value = "$12,235.5"; //Currency Value + ws.Cell("A5").Value = "12%"; //Percentage Value + + var actual = ws.Evaluate("=IsNumber(A1)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNumber(A2)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNumber(A3)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNumber(A4)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsNumber(A5)"); + Assert.AreEqual(true, actual); } #endregion IsNumber Tests @@ -265,41 +239,37 @@ public void IsNumber_Simple_true() [Test] public void IsOdd_Simple_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - - ws.Cell("A1").Value = 4; - ws.Cell("A2").Value = 0.2; - ws.Cell("A3").Value = 12.2; - - var actual = ws.Evaluate("=IsOdd(A1)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsOdd(A2)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsOdd(A3)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + + ws.Cell("A1").Value = 4; + ws.Cell("A2").Value = 0.2; + ws.Cell("A3").Value = 12.2; + + var actual = ws.Evaluate("=IsOdd(A1)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsOdd(A2)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsOdd(A3)"); + Assert.AreEqual(false, actual); } [Test] public void IsOdd_Simple_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - - ws.Cell("A1").Value = 1; - ws.Cell("A2").Value = 1.2; - ws.Cell("A3").Value = 3; - - var actual = ws.Evaluate("=IsOdd(A1)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsOdd(A2)"); - Assert.AreEqual(true, actual); - actual = ws.Evaluate("=IsOdd(A3)"); - Assert.AreEqual(true, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + + ws.Cell("A1").Value = 1; + ws.Cell("A2").Value = 1.2; + ws.Cell("A3").Value = 3; + + var actual = ws.Evaluate("=IsOdd(A1)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsOdd(A2)"); + Assert.AreEqual(true, actual); + actual = ws.Evaluate("=IsOdd(A3)"); + Assert.AreEqual(true, actual); } #endregion IsOdd Test @@ -307,25 +277,23 @@ public void IsOdd_Simple_true() [Test] public void IsRef() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "123"; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "123"; - ws.Cell("B1").FormulaA1 = "ISREF(A1)"; - ws.Cell("B2").FormulaA1 = "ISREF(5)"; - ws.Cell("B3").FormulaA1 = "ISREF(YEAR(TODAY()))"; + ws.Cell("B1").FormulaA1 = "ISREF(A1)"; + ws.Cell("B2").FormulaA1 = "ISREF(5)"; + ws.Cell("B3").FormulaA1 = "ISREF(YEAR(TODAY()))"; - bool actual; - actual = ws.Cell("B1").GetValue(); - Assert.AreEqual(true, actual); + bool actual; + actual = ws.Cell("B1").GetValue(); + Assert.AreEqual(true, actual); - actual = ws.Cell("B2").GetValue(); - Assert.AreEqual(false, actual); + actual = ws.Cell("B2").GetValue(); + Assert.AreEqual(false, actual); - actual = ws.Cell("B3").GetValue(); - Assert.AreEqual(false, actual); - } + actual = ws.Cell("B3").GetValue(); + Assert.AreEqual(false, actual); } #region IsText Tests @@ -333,43 +301,39 @@ public void IsRef() [Test] public void IsText_Simple_false() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "123"; //Double Value - ws.Cell("A2").Value = DateTime.Now; //Date Value - ws.Cell("A3").Value = "12,235.5"; //Comma Formatting - ws.Cell("A4").Value = "$12,235.5"; //Currency Value - ws.Cell("A5").Value = true; //Bool Value - ws.Cell("A6").Value = "12%"; //Percentage Value - - var actual = ws.Evaluate("=IsText(A1)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsText(A2)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsText(A3)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsText(A4)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsText(A5)"); - Assert.AreEqual(false, actual); - actual = ws.Evaluate("=IsText(A6)"); - Assert.AreEqual(false, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "123"; //Double Value + ws.Cell("A2").Value = DateTime.Now; //Date Value + ws.Cell("A3").Value = "12,235.5"; //Comma Formatting + ws.Cell("A4").Value = "$12,235.5"; //Currency Value + ws.Cell("A5").Value = true; //Bool Value + ws.Cell("A6").Value = "12%"; //Percentage Value + + var actual = ws.Evaluate("=IsText(A1)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsText(A2)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsText(A3)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsText(A4)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsText(A5)"); + Assert.AreEqual(false, actual); + actual = ws.Evaluate("=IsText(A6)"); + Assert.AreEqual(false, actual); } [Test] public void IsText_Simple_true() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "asd"; + ws.Cell("A1").Value = "asd"; - var actual = ws.Evaluate("=IsText(A1)"); - Assert.AreEqual(true, actual); - } + var actual = ws.Evaluate("=IsText(A1)"); + Assert.AreEqual(true, actual); } #endregion IsText Tests @@ -379,63 +343,53 @@ public void IsText_Simple_true() [Test] public void N_Date_SerialNumber() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - var testedDate = DateTime.Now; - ws.Cell("A1").Value = testedDate; - var actual = ws.Evaluate("=N(A1)"); - Assert.AreEqual(testedDate.ToOADate(), actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + var testedDate = DateTime.Now; + ws.Cell("A1").Value = testedDate; + var actual = ws.Evaluate("=N(A1)"); + Assert.AreEqual(testedDate.ToOADate(), actual); } [Test] public void N_False_Zero() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = false; - var actual = ws.Evaluate("=N(A1)"); - Assert.AreEqual(0, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = false; + var actual = ws.Evaluate("=N(A1)"); + Assert.AreEqual(0, actual); } [Test] public void N_Number_Number() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - var testedValue = 123; - ws.Cell("A1").Value = testedValue; - var actual = ws.Evaluate("=N(A1)"); - Assert.AreEqual(testedValue, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + var testedValue = 123; + ws.Cell("A1").Value = testedValue; + var actual = ws.Evaluate("=N(A1)"); + Assert.AreEqual(testedValue, actual); } [Test] public void N_String_Zero() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = "asd"; - var actual = ws.Evaluate("=N(A1)"); - Assert.AreEqual(0, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = "asd"; + var actual = ws.Evaluate("=N(A1)"); + Assert.AreEqual(0, actual); } [Test] public void N_True_One() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").Value = true; - var actual = ws.Evaluate("=N(A1)"); - Assert.AreEqual(1, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").Value = true; + var actual = ws.Evaluate("=N(A1)"); + Assert.AreEqual(1, actual); } #endregion N Tests diff --git a/ClosedXML.Tests/Excel/CalcEngine/LogicalTests.cs b/ClosedXML.Tests/Excel/CalcEngine/LogicalTests.cs index f45050c27..dd297a8e7 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/LogicalTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/LogicalTests.cs @@ -1,6 +1,5 @@ using ClosedXML.Excel; using NUnit.Framework; -using System; namespace ClosedXML.Tests.Excel.CalcEngine { @@ -10,35 +9,35 @@ public class LogicalTests [Test] public void If_2_Params_true() { - Object actual = XLWorkbook.EvaluateExpr(@"if(1 = 1, ""T"")"); + var actual = XLWorkbook.EvaluateExpr(@"if(1 = 1, ""T"")"); Assert.AreEqual("T", actual); } [Test] public void If_2_Params_false() { - Object actual = XLWorkbook.EvaluateExpr(@"if(1 = 2, ""T"")"); + var actual = XLWorkbook.EvaluateExpr(@"if(1 = 2, ""T"")"); Assert.AreEqual(false, actual); } [Test] public void If_3_Params_true() { - Object actual = XLWorkbook.EvaluateExpr(@"if(1 = 1, ""T"", ""F"")"); + var actual = XLWorkbook.EvaluateExpr(@"if(1 = 1, ""T"", ""F"")"); Assert.AreEqual("T", actual); } [Test] public void If_3_Params_false() { - Object actual = XLWorkbook.EvaluateExpr(@"if(1 = 2, ""T"", ""F"")"); + var actual = XLWorkbook.EvaluateExpr(@"if(1 = 2, ""T"", ""F"")"); Assert.AreEqual("F", actual); } [Test] public void If_Comparing_Against_Empty_String() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"if(date(2016, 1, 1) = """", ""A"",""B"")"); Assert.AreEqual("B", actual); @@ -55,7 +54,7 @@ public void If_Comparing_Against_Empty_String() [Test] public void If_Case_Insensitivity() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"IF(""text""=""TEXT"", 1, 2)"); Assert.AreEqual(1, actual); } diff --git a/ClosedXML.Tests/Excel/CalcEngine/LookupTests.cs b/ClosedXML.Tests/Excel/CalcEngine/LookupTests.cs index 354419603..d364f77ae 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/LookupTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/LookupTests.cs @@ -8,29 +8,24 @@ namespace ClosedXML.Tests.Excel.CalcEngine { [TestFixture] - public class LookupTests + public class LookupTests : IDisposable { + private XLWorkbook wb; private XLWorkbook workbook; - - #region Setup and teardown - - [OneTimeTearDown] - public void Dispose() - { - workbook.Dispose(); - } + private bool disposedValue; [SetUp] public void Init() { // Make sure tests run on a deterministic culture System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); + workbook = SetupWorkbook(); } private XLWorkbook SetupWorkbook() { - var wb = new XLWorkbook(); + wb = new XLWorkbook(); var ws = wb.AddWorksheet("Data"); var data = new object[] { @@ -86,8 +81,6 @@ private XLWorkbook SetupWorkbook() return wb; } - #endregion Setup and teardown - [Test] public void Hlookup() { @@ -150,7 +143,7 @@ public void Match() { var ws = workbook.Worksheets.First(); - Object value; + object value; value = ws.Evaluate(@"=MATCH(""Rep"", B2:I2, 0)"); Assert.AreEqual(4, value); @@ -246,5 +239,25 @@ public void Vlookup_Exceptions() Assert.Throws(() => workbook.Evaluate(@"=VLOOKUP(20,Data!$B$2:$I$71,9,FALSE)")); } + + protected virtual void Dispose(bool disposing) + { + if (!disposedValue) + { + if (disposing) + { + workbook?.Dispose(); + wb?.Dispose(); + } + + disposedValue = true; + } + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/MathTrigTests.cs b/ClosedXML.Tests/Excel/CalcEngine/MathTrigTests.cs index b0a2629b8..46c58c588 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/MathTrigTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/MathTrigTests.cs @@ -280,7 +280,7 @@ public void Atan2_Returns0OnSecond0AndFirstGreater0([Range(0.1, 5, 0.4)] double [TestCase(6, 7, 0.86217005466723)] public void Atan2_ReturnsCorrectResults_EqualOnAllMultiplesOfFraction(double x, double y, double expectedResult) { - for (int i = 1; i < 5; i++) + for (var i = 1; i < 5; i++) { var actual = (double)XLWorkbook.EvaluateExpr( string.Format( @@ -488,12 +488,14 @@ public void Ceiling_ThrowsNumberExceptionOnInvalidInput(double input, double sig [TestCase(-5.5, 0, 10, 0)] public void CeilingMath(double input, double? step, int? mode, double expectedResult) { - string parameters = input.ToString(CultureInfo.InvariantCulture); + var parameters = input.ToString(CultureInfo.InvariantCulture); if (step != null) { parameters = parameters + ", " + step?.ToString(CultureInfo.InvariantCulture); if (mode != null) + { parameters = parameters + ", " + mode?.ToString(CultureInfo.InvariantCulture); + } } var actual = (double)XLWorkbook.EvaluateExpr($"CEILING.MATH({parameters})"); @@ -987,12 +989,14 @@ public void Floor_ThrowsNumberExceptionOnInvalidInput(double input, double signi [TestCase(-5.5, 0, 0, 0)] public void FloorMath(double input, double? step, int? mode, double expectedResult) { - string parameters = input.ToString(CultureInfo.InvariantCulture); + var parameters = input.ToString(CultureInfo.InvariantCulture); if (step != null) { parameters = parameters + ", " + step?.ToString(CultureInfo.InvariantCulture); if (mode != null) + { parameters = parameters + ", " + mode?.ToString(CultureInfo.InvariantCulture); + } } var actual = (double)XLWorkbook.EvaluateExpr(string.Format(@"FLOOR.MATH({0})", parameters)); @@ -1064,14 +1068,14 @@ public void Mod() [DefaultFloatingPointTolerance(1e-12)] public double MRound(double number, double multiple) { - return (double)XLWorkbook.EvaluateExpr($"MROUND({number}, {multiple})"); + return (double)XLWorkbook.EvaluateExpr($"MROUND({number.ToInvariantString()}, {multiple.ToInvariantString()})"); } [TestCase(123456.123, -10)] [TestCase(-123456.123, 5)] public void MRoundExceptions(double number, double multiple) { - Assert.Throws(() => XLWorkbook.EvaluateExpr($"MROUND({number}, {multiple})")); + Assert.Throws(() => XLWorkbook.EvaluateExpr($"MROUND({number.ToInvariantString()}, {multiple.ToInvariantString()})")); } [TestCase(0, 1)] @@ -1117,14 +1121,14 @@ public void MRoundExceptions(double number, double multiple) [TestCase(30, 6.48292)] public void Sec_ReturnsCorrectNumber(double input, double expectedOutput) { - double result = (double)XLWorkbook.EvaluateExpr( + var result = (double)XLWorkbook.EvaluateExpr( string.Format( @"SEC({0})", input.ToString(CultureInfo.InvariantCulture))); Assert.AreEqual(expectedOutput, result, 0.00001); // as the secant is symmetric for positive and negative numbers, let's assert twice: - double resultForNegative = (double)XLWorkbook.EvaluateExpr( + var resultForNegative = (double)XLWorkbook.EvaluateExpr( string.Format( @"SEC({0})", (-input).ToString(CultureInfo.InvariantCulture))); @@ -1149,14 +1153,14 @@ public void Sec_ThrowsCellValueExceptionOnNonNumericValue() [TestCase(0, 1)] public void Sech_ReturnsCorrectNumber(double input, double expectedOutput) { - double result = (double)XLWorkbook.EvaluateExpr( + var result = (double)XLWorkbook.EvaluateExpr( string.Format( @"SECH({0})", input.ToString(CultureInfo.InvariantCulture))); Assert.AreEqual(expectedOutput, result, 0.00001); // as the secant is symmetric for positive and negative numbers, let's assert twice: - double resultForNegative = (double)XLWorkbook.EvaluateExpr( + var resultForNegative = (double)XLWorkbook.EvaluateExpr( string.Format( @"SECH({0})", (-input).ToString(CultureInfo.InvariantCulture))); @@ -1175,24 +1179,22 @@ public void Sech_ReturnsCorrectNumber(double input, double expectedOutput) [TestCase(28000, "SUMIF(A1:A4, \">\" &C1, B1:B4)")] public void SumIf_ReturnsCorrectValues_ReferenceExample1FromMicrosoft(int expectedOutcome, string formula) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(1, 1).Value = 100000; - ws.Cell(1, 2).Value = 7000; - ws.Cell(2, 1).Value = 200000; - ws.Cell(2, 2).Value = 14000; - ws.Cell(3, 1).Value = 300000; - ws.Cell(3, 2).Value = 21000; - ws.Cell(4, 1).Value = 400000; - ws.Cell(4, 2).Value = 28000; + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell(1, 1).Value = 100000; + ws.Cell(1, 2).Value = 7000; + ws.Cell(2, 1).Value = 200000; + ws.Cell(2, 2).Value = 14000; + ws.Cell(3, 1).Value = 300000; + ws.Cell(3, 2).Value = 21000; + ws.Cell(4, 1).Value = 400000; + ws.Cell(4, 2).Value = 28000; - ws.Cell(1, 3).Value = 300000; + ws.Cell(1, 3).Value = 300000; - Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); - } + Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); } /// @@ -1207,81 +1209,75 @@ public void SumIf_ReturnsCorrectValues_ReferenceExample1FromMicrosoft(int expect [TestCase(400, "SUMIF(A2:A7, \"\", C2:C7)")] public void SumIf_ReturnsCorrectValues_ReferenceExample2FromMicrosoft(int expectedOutcome, string formula) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; - - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(2, 1).Value = "Vegetables"; - ws.Cell(3, 1).Value = "Vegetables"; - ws.Cell(4, 1).Value = "Fruits"; - ws.Cell(5, 1).Value = ""; - ws.Cell(6, 1).Value = "Vegetables"; - ws.Cell(7, 1).Value = "Fruits"; - - ws.Cell(2, 2).Value = "Tomatoes"; - ws.Cell(3, 2).Value = "Celery"; - ws.Cell(4, 2).Value = "Oranges"; - ws.Cell(5, 2).Value = "Butter"; - ws.Cell(6, 2).Value = "Carrots"; - ws.Cell(7, 2).Value = "Apples"; - - ws.Cell(2, 3).Value = 2300; - ws.Cell(3, 3).Value = 5500; - ws.Cell(4, 3).Value = 800; - ws.Cell(5, 3).Value = 400; - ws.Cell(6, 3).Value = 4200; - ws.Cell(7, 3).Value = 1200; - - ws.Cell(1, 3).Value = 300000; - - Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); - } + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; + + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell(2, 1).Value = "Vegetables"; + ws.Cell(3, 1).Value = "Vegetables"; + ws.Cell(4, 1).Value = "Fruits"; + ws.Cell(5, 1).Value = ""; + ws.Cell(6, 1).Value = "Vegetables"; + ws.Cell(7, 1).Value = "Fruits"; + + ws.Cell(2, 2).Value = "Tomatoes"; + ws.Cell(3, 2).Value = "Celery"; + ws.Cell(4, 2).Value = "Oranges"; + ws.Cell(5, 2).Value = "Butter"; + ws.Cell(6, 2).Value = "Carrots"; + ws.Cell(7, 2).Value = "Apples"; + + ws.Cell(2, 3).Value = 2300; + ws.Cell(3, 3).Value = 5500; + ws.Cell(4, 3).Value = 800; + ws.Cell(5, 3).Value = 400; + ws.Cell(6, 3).Value = 4200; + ws.Cell(7, 3).Value = 1200; + + ws.Cell(1, 3).Value = 300000; + + Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); } [Test] public void SumIf_ReturnsCorrectValues_WhenCalledOnFullColumn() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Data"); + var data = new object[] { - var ws = wb.AddWorksheet("Data"); - var data = new object[] - { new { Id = "A", Value = 2}, new { Id = "B", Value = 3}, new { Id = "C", Value = 2}, new { Id = "A", Value = 1}, new { Id = "B", Value = 4} - }; - ws.Cell("A1").InsertTable(data); - var formula = "=SUMIF(A:A,\"=A\",B:B)"; - var value = ws.Evaluate(formula); - Assert.AreEqual(3, value); - } + }; + ws.Cell("A1").InsertTable(data); + var formula = "=SUMIF(A:A,\"=A\",B:B)"; + var value = ws.Evaluate(formula); + Assert.AreEqual(3, value); } [Test] public void SumIf_ReturnsCorrectValues_WhenFormulaBelongToSameRange() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Data"); + var data = new object[] { - var ws = wb.AddWorksheet("Data"); - var data = new object[] - { new { Id = "A", Value = 2}, new { Id = "B", Value = 3}, new { Id = "C", Value = 2}, new { Id = "A", Value = 1}, new { Id = "B", Value = 4}, - }; - ws.Cell("A1").InsertTable(data); - ws.Cell("A7").SetValue("Sum A"); - // SUMIF formula - var formula = "=SUMIF(A:A,\"=A\",B:B)"; - ws.Cell("B7").SetFormulaA1(formula); - var value = ws.Cell("B7").Value; - Assert.AreEqual(3, value); - } + }; + ws.Cell("A1").InsertTable(data); + ws.Cell("A7").SetValue("Sum A"); + // SUMIF formula + var formula = "=SUMIF(A:A,\"=A\",B:B)"; + ws.Cell("B7").SetFormulaA1(formula); + var value = ws.Cell("B7").Value; + Assert.AreEqual(3, value); } /// @@ -1297,37 +1293,35 @@ public void SumIf_ReturnsCorrectValues_WhenFormulaBelongToSameRange() [TestCase(400, "SUMIFS(C2:C7, A2:A7, \"\")")] public void SumIfs_ReturnsCorrectValues_ReferenceExample2FromMicrosoft(int expectedResult, string formula) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; - - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(2, 1).Value = "Vegetables"; - ws.Cell(3, 1).Value = "Vegetables"; - ws.Cell(4, 1).Value = "Fruits"; - ws.Cell(5, 1).Value = ""; - ws.Cell(6, 1).Value = "Vegetables"; - ws.Cell(7, 1).Value = "Fruits"; - - ws.Cell(2, 2).Value = "Tomatoes"; - ws.Cell(3, 2).Value = "Celery"; - ws.Cell(4, 2).Value = "Oranges"; - ws.Cell(5, 2).Value = "Butter"; - ws.Cell(6, 2).Value = "Carrots"; - ws.Cell(7, 2).Value = "Apples"; - - ws.Cell(2, 3).Value = 2300; - ws.Cell(3, 3).Value = 5500; - ws.Cell(4, 3).Value = 800; - ws.Cell(5, 3).Value = 400; - ws.Cell(6, 3).Value = 4200; - ws.Cell(7, 3).Value = 1200; - - ws.Cell(1, 3).Value = 300000; - - var actualResult = ws.Evaluate(formula).CastTo(); - Assert.AreEqual(expectedResult, actualResult); - } + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; + + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell(2, 1).Value = "Vegetables"; + ws.Cell(3, 1).Value = "Vegetables"; + ws.Cell(4, 1).Value = "Fruits"; + ws.Cell(5, 1).Value = ""; + ws.Cell(6, 1).Value = "Vegetables"; + ws.Cell(7, 1).Value = "Fruits"; + + ws.Cell(2, 2).Value = "Tomatoes"; + ws.Cell(3, 2).Value = "Celery"; + ws.Cell(4, 2).Value = "Oranges"; + ws.Cell(5, 2).Value = "Butter"; + ws.Cell(6, 2).Value = "Carrots"; + ws.Cell(7, 2).Value = "Apples"; + + ws.Cell(2, 3).Value = 2300; + ws.Cell(3, 3).Value = 5500; + ws.Cell(4, 3).Value = 800; + ws.Cell(5, 3).Value = 400; + ws.Cell(6, 3).Value = 4200; + ws.Cell(7, 3).Value = 1200; + + ws.Cell(1, 3).Value = 300000; + + var actualResult = ws.Evaluate(formula).CastTo(); + Assert.AreEqual(expectedResult, actualResult); } /// @@ -1342,24 +1336,22 @@ public void SumIfs_ReturnsCorrectValues_ReferenceExample2FromMicrosoft(int expec [TestCase(28000, "SUMIFS(B1:B4, A1:A4, \">\" &C1)")] public void SumIfs_ReturnsCorrectValues_ReferenceExampleForSumIf1FromMicrosoft(int expectedOutcome, string formula) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(1, 1).Value = 100000; - ws.Cell(1, 2).Value = 7000; - ws.Cell(2, 1).Value = 200000; - ws.Cell(2, 2).Value = 14000; - ws.Cell(3, 1).Value = 300000; - ws.Cell(3, 2).Value = 21000; - ws.Cell(4, 1).Value = 400000; - ws.Cell(4, 2).Value = 28000; + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell(1, 1).Value = 100000; + ws.Cell(1, 2).Value = 7000; + ws.Cell(2, 1).Value = 200000; + ws.Cell(2, 2).Value = 14000; + ws.Cell(3, 1).Value = 300000; + ws.Cell(3, 2).Value = 21000; + ws.Cell(4, 1).Value = 400000; + ws.Cell(4, 2).Value = 28000; - ws.Cell(1, 3).Value = 300000; + ws.Cell(1, 3).Value = 300000; - Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); - } + Assert.AreEqual(expectedOutcome, (double)ws.Evaluate(formula)); } /// @@ -1372,81 +1364,77 @@ public void SumIfs_ReturnsCorrectValues_ReferenceExampleFromMicrosoft( int expectedResult, string formula) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; + var ws = wb.AddWorksheet("Sheet1"); - var row = 2; + var row = 2; - ws.Cell(row, 1).Value = 5; - ws.Cell(row, 2).Value = "Apples"; - ws.Cell(row, 3).Value = "Tom"; - row++; + ws.Cell(row, 1).Value = 5; + ws.Cell(row, 2).Value = "Apples"; + ws.Cell(row, 3).Value = "Tom"; + row++; - ws.Cell(row, 1).Value = 4; - ws.Cell(row, 2).Value = "Apples"; - ws.Cell(row, 3).Value = "Sarah"; - row++; + ws.Cell(row, 1).Value = 4; + ws.Cell(row, 2).Value = "Apples"; + ws.Cell(row, 3).Value = "Sarah"; + row++; - ws.Cell(row, 1).Value = 15; - ws.Cell(row, 2).Value = "Artichokes"; - ws.Cell(row, 3).Value = "Tom"; - row++; + ws.Cell(row, 1).Value = 15; + ws.Cell(row, 2).Value = "Artichokes"; + ws.Cell(row, 3).Value = "Tom"; + row++; - ws.Cell(row, 1).Value = 3; - ws.Cell(row, 2).Value = "Artichokes"; - ws.Cell(row, 3).Value = "Sarah"; - row++; + ws.Cell(row, 1).Value = 3; + ws.Cell(row, 2).Value = "Artichokes"; + ws.Cell(row, 3).Value = "Sarah"; + row++; - ws.Cell(row, 1).Value = 22; - ws.Cell(row, 2).Value = "Bananas"; - ws.Cell(row, 3).Value = "Tom"; - row++; + ws.Cell(row, 1).Value = 22; + ws.Cell(row, 2).Value = "Bananas"; + ws.Cell(row, 3).Value = "Tom"; + row++; - ws.Cell(row, 1).Value = 12; - ws.Cell(row, 2).Value = "Bananas"; - ws.Cell(row, 3).Value = "Sarah"; - row++; + ws.Cell(row, 1).Value = 12; + ws.Cell(row, 2).Value = "Bananas"; + ws.Cell(row, 3).Value = "Sarah"; + row++; - ws.Cell(row, 1).Value = 10; - ws.Cell(row, 2).Value = "Carrots"; - ws.Cell(row, 3).Value = "Tom"; - row++; + ws.Cell(row, 1).Value = 10; + ws.Cell(row, 2).Value = "Carrots"; + ws.Cell(row, 3).Value = "Tom"; + row++; - ws.Cell(row, 1).Value = 33; - ws.Cell(row, 2).Value = "Carrots"; - ws.Cell(row, 3).Value = "Sarah"; + ws.Cell(row, 1).Value = 33; + ws.Cell(row, 2).Value = "Carrots"; + ws.Cell(row, 3).Value = "Sarah"; - var actualResult = ws.Evaluate(formula).CastTo(); + var actualResult = ws.Evaluate(formula).CastTo(); - Assert.AreEqual(expectedResult, actualResult, tolerance); - } + Assert.AreEqual(expectedResult, actualResult, tolerance); } [Test] public void SumProduct() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = Enumerable.Range(1, 10); - ws.FirstCell().CellRight().Value = Enumerable.Range(1, 10).Reverse(); + ws.FirstCell().Value = Enumerable.Range(1, 10); + ws.FirstCell().CellRight().Value = Enumerable.Range(1, 10).Reverse(); - Assert.AreEqual(2, ws.Evaluate("SUMPRODUCT(A2)")); - Assert.AreEqual(55, ws.Evaluate("SUMPRODUCT(A1:A10)")); - Assert.AreEqual(220, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); + Assert.AreEqual(2, ws.Evaluate("SUMPRODUCT(A2)")); + Assert.AreEqual(55, ws.Evaluate("SUMPRODUCT(A1:A10)")); + Assert.AreEqual(220, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); - Assert.Throws(() => ws.Evaluate("SUMPRODUCT(A1:A10, B1:B5)")); + Assert.Throws(() => ws.Evaluate("SUMPRODUCT(A1:A10, B1:B5)")); - // Blank cells and cells with text should be treated as zeros - ws.Range("A1:A5").Clear(); - Assert.AreEqual(110, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); + // Blank cells and cells with text should be treated as zeros + ws.Range("A1:A5").Clear(); + Assert.AreEqual(110, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); - ws.Range("A1:A5").SetValue("asdf"); - Assert.AreEqual(110, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); - } + ws.Range("A1:A5").SetValue("asdf"); + Assert.AreEqual(110, ws.Evaluate("SUMPRODUCT(A1:A10, B1:B10)")); } [Test] diff --git a/ClosedXML.Tests/Excel/CalcEngine/PrecedentCellsTests.cs b/ClosedXML.Tests/Excel/CalcEngine/PrecedentCellsTests.cs index 7555455c5..01f843a69 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/PrecedentCellsTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/PrecedentCellsTests.cs @@ -11,90 +11,76 @@ public class PrecedentCellsTests [Test] public void GetPrecedentRangesPreventsDuplication() { - using (var ms = new MemoryStream()) - { - using (XLWorkbook wb = new XLWorkbook()) - { - var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; - var sheet2 = wb.AddWorksheet("Sheet2"); - var formula = "=MAX(A2:E2)/COUNTBLANK(A2:E2)*MAX(B1:C3)+SUM(Sheet2!B1:C3)+SUM($A$2:$E$2)+A2+B$2+$C$2"; + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; + var sheet2 = wb.AddWorksheet("Sheet2"); + var formula = "=MAX(A2:E2)/COUNTBLANK(A2:E2)*MAX(B1:C3)+SUM(Sheet2!B1:C3)+SUM($A$2:$E$2)+A2+B$2+$C$2"; - var ranges = sheet1.CalcEngine.GetPrecedentRanges(formula); + var ranges = sheet1.CalcEngine.GetPrecedentRanges(formula); - Assert.AreEqual(6, ranges.Count()); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "A2:E2")); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "B1:C3")); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet2" && r.RangeAddress.ToString() == "B1:C3")); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "A2:A2")); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "B$2:B$2")); - Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "$C$2:$C$2")); - } - } + Assert.AreEqual(6, ranges.Count()); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "A2:E2")); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "B1:C3")); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet2" && r.RangeAddress.ToString() == "B1:C3")); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "A2:A2")); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "B$2:B$2")); + Assert.IsTrue(ranges.Any(r => r.RangeAddress.Worksheet.Name == "Sheet1" && r.RangeAddress.ToString() == "$C$2:$C$2")); } [Test] public void GetPrecedentRangesDealsWithNamedRanges() { - using (var ms = new MemoryStream()) - { - using (XLWorkbook wb = new XLWorkbook()) - { - var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; - sheet1.NamedRanges.Add("NAMED_RANGE", sheet1.Range("A2:B3")); - var formula = "=SUM(NAMED_RANGE)"; + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; + sheet1.NamedRanges.Add("NAMED_RANGE", sheet1.Range("A2:B3")); + var formula = "=SUM(NAMED_RANGE)"; - var ranges = sheet1.CalcEngine.GetPrecedentRanges(formula); + var ranges = sheet1.CalcEngine.GetPrecedentRanges(formula); - Assert.AreEqual(1, ranges.Count()); - Assert.AreEqual("$A$2:$B$3", ranges.First().RangeAddress.ToString()); - } - } + Assert.AreEqual(1, ranges.Count()); + Assert.AreEqual("$A$2:$B$3", ranges.First().RangeAddress.ToString()); } [Test] public void GetPrecedentCells() { - using (var ms = new MemoryStream()) - { - using (XLWorkbook wb = new XLWorkbook()) - { - var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; - var sheet2 = wb.AddWorksheet("Sheet2"); - var formula = "=MAX(A2:E2)/COUNTBLANK(A2:E2)*MAX(B1:C3)+SUM(Sheet2!B1:C3)+SUM($A$2:$E$2)+A2+B$2+$C$2"; - var expectedAtSheet1 = new string[] - { "A2", "B2", "C2", "D2", "E2", "B1", "C1", "B3", "C3" }; - var expectedAtSheet2 = new string[] - { "B1", "C1", "B2", "C2", "B3", "C3" }; + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + var sheet1 = wb.AddWorksheet("Sheet1") as XLWorksheet; + var sheet2 = wb.AddWorksheet("Sheet2"); + var formula = "=MAX(A2:E2)/COUNTBLANK(A2:E2)*MAX(B1:C3)+SUM(Sheet2!B1:C3)+SUM($A$2:$E$2)+A2+B$2+$C$2"; + var expectedAtSheet1 = new string[] + { "A2", "B2", "C2", "D2", "E2", "B1", "C1", "B3", "C3" }; + var expectedAtSheet2 = new string[] + { "B1", "C1", "B2", "C2", "B3", "C3" }; - var cells = sheet1.CalcEngine.GetPrecedentCells(formula); + var cells = sheet1.CalcEngine.GetPrecedentCells(formula); - Assert.AreEqual(15, cells.Count()); - foreach (var address in expectedAtSheet1) - { - Assert.IsTrue(cells.Any(cell => cell.Address.Worksheet.Name == sheet1.Name && cell.Address.ToString() == address), - string.Format("Address {0}!{1} is not presented", sheet1.Name, address)); - } - foreach (var address in expectedAtSheet2) - { - Assert.IsTrue(cells.Any(cell => cell.Address.Worksheet.Name == sheet2.Name && cell.Address.ToString() == address), - string.Format("Address {0}!{1} is not presented", sheet2.Name, address)); - } - } + Assert.AreEqual(15, cells.Count()); + foreach (var address in expectedAtSheet1) + { + Assert.IsTrue(cells.Any(cell => cell.Address.Worksheet.Name == sheet1.Name && cell.Address.ToString() == address), + string.Format("Address {0}!{1} is not presented", sheet1.Name, address)); + } + foreach (var address in expectedAtSheet2) + { + Assert.IsTrue(cells.Any(cell => cell.Address.Worksheet.Name == sheet2.Name && cell.Address.ToString() == address), + string.Format("Address {0}!{1} is not presented", sheet2.Name, address)); } } [Test] public void CanParseWorksheetNamesWithExclamationMark() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet() as XLWorksheet; - var ws2 = wb.AddWorksheet("Worksheet!"); - var expectedCell = ws2.Cell("B2"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet() as XLWorksheet; + var ws2 = wb.AddWorksheet("Worksheet!"); + var expectedCell = ws2.Cell("B2"); - var cells = ws1.CalcEngine.GetPrecedentCells("='Worksheet!'!B2*2"); - Assert.AreSame(expectedCell, cells.Single()); - } + var cells = ws1.CalcEngine.GetPrecedentCells("='Worksheet!'!B2*2"); + Assert.AreSame(expectedCell, cells.Single()); } } } diff --git a/ClosedXML.Tests/Excel/CalcEngine/StatisticalTests.cs b/ClosedXML.Tests/Excel/CalcEngine/StatisticalTests.cs index 41df29a35..1d5322a1a 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/StatisticalTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/StatisticalTests.cs @@ -1,4 +1,3 @@ -// Keep this file CodeMaid organised and cleaned using ClosedXML.Excel; using ClosedXML.Excel.CalcEngine; using ClosedXML.Excel.CalcEngine.Exceptions; @@ -11,17 +10,24 @@ namespace ClosedXML.Tests.Excel.CalcEngine [TestFixture] public class StatisticalTests { - private double tolerance = 1e-6; - private XLWorkbook workbook; + private readonly double tolerance = 1e-6; + + [SetUp] + public void Init() + { + // Make sure tests run on a deterministic culture + System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); + } [Test] public void Average() { double value; - value = workbook.Evaluate("AVERAGE(-27.5,93.93,64.51,-70.56)").CastTo(); + using var wb = SetupWorkbook(); + value = wb.Evaluate("AVERAGE(-27.5,93.93,64.51,-70.56)").CastTo(); Assert.AreEqual(15.095, value, tolerance); - var ws = workbook.Worksheets.First(); + var ws = wb.Worksheets.First(); value = ws.Evaluate("AVERAGE(G3:G45)").CastTo(); Assert.AreEqual(49.3255814, value, tolerance); @@ -31,7 +37,7 @@ public void Average() [Test] public void Count() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=COUNT(D3:D45)").CastTo(); Assert.AreEqual(0, value); @@ -42,14 +48,14 @@ public void Count() value = ws.Evaluate(@"=COUNT(G:G)").CastTo(); Assert.AreEqual(43, value); - value = workbook.Evaluate(@"=COUNT(Data!G:G)").CastTo(); + value = wb.Evaluate(@"=COUNT(Data!G:G)").CastTo(); Assert.AreEqual(43, value); } [Test] public void CountA() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=COUNTA(D3:D45)").CastTo(); Assert.AreEqual(43, value); @@ -60,14 +66,14 @@ public void CountA() value = ws.Evaluate(@"=COUNTA(G:G)").CastTo(); Assert.AreEqual(44, value); - value = workbook.Evaluate(@"=COUNTA(Data!G:G)").CastTo(); + value = wb.Evaluate(@"=COUNTA(Data!G:G)").CastTo(); Assert.AreEqual(44, value); } [Test] public void CountBlank() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=COUNTBLANK(B:B)").CastTo(); Assert.AreEqual(1048532, value); @@ -81,7 +87,7 @@ public void CountBlank() value = ws.Evaluate(@"=COUNTBLANK(A1)").CastTo(); Assert.AreEqual(1, value); - Assert.Throws(() => workbook.Evaluate(@"=COUNTBLANK(E3:E45)")); + Assert.Throws(() => wb.Evaluate(@"=COUNTBLANK(E3:E45)")); Assert.Throws(() => ws.Evaluate(@"=COUNTBLANK()")); Assert.Throws(() => ws.Evaluate(@"=COUNTBLANK(A3:A45,E3:E45)")); } @@ -89,7 +95,7 @@ public void CountBlank() [Test] public void CountIf() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=COUNTIF(D3:D45,""Central"")").CastTo(); Assert.AreEqual(24, value); @@ -97,7 +103,7 @@ public void CountIf() value = ws.Evaluate(@"=COUNTIF(D:D,""Central"")").CastTo(); Assert.AreEqual(24, value); - value = workbook.Evaluate(@"=COUNTIF(Data!D:D,""Central"")").CastTo(); + value = wb.Evaluate(@"=COUNTIF(Data!D:D,""Central"")").CastTo(); Assert.AreEqual(24, value); } @@ -111,9 +117,9 @@ public void CountIf() [TestCase(@"=COUNTIF(Data!E1:E44, """")", 1)] public void CountIf_ConditionWithWildcards(string formula, int expectedResult) { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); - int value = ws.Evaluate(formula).CastTo(); + var value = ws.Evaluate(formula).CastTo(); Assert.AreEqual(expectedResult, value); } @@ -129,7 +135,7 @@ public void CountIf_MixedData(string formula, int expected) // We follow to Excel's convention. // Excel treats 1 and TRUE as unequal, but 3 and "3" as equal // LibreOffice Calc handles some SUMIF and COUNTIF differently, e.g. it treats 1 and TRUE as equal, but 3 and "3" differently - var ws = workbook.Worksheet("MixedData"); + using var wb = SetupWorkbook(); var ws = wb.Worksheet("MixedData"); Assert.AreEqual(expected, ws.Evaluate(formula)); } @@ -150,14 +156,12 @@ public void CountIf_MixedData(string formula, int expected) [TestCase("~xyz", @"=COUNTIF(A1:A1, ""~~*"")", 1)] public void CountIf_MoreWildcards(string cellContent, string formula, int expectedResult) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(1, 1).Value = cellContent; + ws.Cell(1, 1).Value = cellContent; - Assert.AreEqual(expectedResult, (double)ws.Evaluate(formula)); - } + Assert.AreEqual(expectedResult, (double)ws.Evaluate(formula)); } [TestCase("=COUNTIFS(B1:D1, \"=Yes\")", 1)] @@ -167,40 +171,38 @@ public void CountIfs_ReferenceExample1FromExcelDocumentations( string formula, int expectedOutcome) { - using (var wb = new XLWorkbook()) - { - wb.ReferenceStyle = XLReferenceStyle.A1; + using var wb = new XLWorkbook(); + wb.ReferenceStyle = XLReferenceStyle.A1; - var ws = wb.AddWorksheet("Sheet1"); + var ws = wb.AddWorksheet("Sheet1"); - ws.Cell(1, 1).Value = "Davidoski"; - ws.Cell(1, 2).Value = "Yes"; - ws.Cell(1, 3).Value = "No"; - ws.Cell(1, 4).Value = "No"; + ws.Cell(1, 1).Value = "Davidoski"; + ws.Cell(1, 2).Value = "Yes"; + ws.Cell(1, 3).Value = "No"; + ws.Cell(1, 4).Value = "No"; - ws.Cell(2, 1).Value = "Burke"; - ws.Cell(2, 2).Value = "Yes"; - ws.Cell(2, 3).Value = "Yes"; - ws.Cell(2, 4).Value = "No"; + ws.Cell(2, 1).Value = "Burke"; + ws.Cell(2, 2).Value = "Yes"; + ws.Cell(2, 3).Value = "Yes"; + ws.Cell(2, 4).Value = "No"; - ws.Cell(3, 1).Value = "Sundaram"; - ws.Cell(3, 2).Value = "Yes"; - ws.Cell(3, 3).Value = "Yes"; - ws.Cell(3, 4).Value = "Yes"; + ws.Cell(3, 1).Value = "Sundaram"; + ws.Cell(3, 2).Value = "Yes"; + ws.Cell(3, 3).Value = "Yes"; + ws.Cell(3, 4).Value = "Yes"; - ws.Cell(4, 1).Value = "Levitan"; - ws.Cell(4, 2).Value = "No"; - ws.Cell(4, 3).Value = "Yes"; - ws.Cell(4, 4).Value = "Yes"; + ws.Cell(4, 1).Value = "Levitan"; + ws.Cell(4, 2).Value = "No"; + ws.Cell(4, 3).Value = "Yes"; + ws.Cell(4, 4).Value = "Yes"; - Assert.AreEqual(expectedOutcome, ws.Evaluate(formula)); - } + Assert.AreEqual(expectedOutcome, ws.Evaluate(formula)); } [Test] public void CountIfs_SingleCondition() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=COUNTIFS(D3:D45,""Central"")").CastTo(); Assert.AreEqual(24, value); @@ -208,7 +210,7 @@ public void CountIfs_SingleCondition() value = ws.Evaluate(@"=COUNTIFS(D:D,""Central"")").CastTo(); Assert.AreEqual(24, value); - value = workbook.Evaluate(@"=COUNTIFS(Data!D:D,""Central"")").CastTo(); + value = wb.Evaluate(@"=COUNTIFS(Data!D:D,""Central"")").CastTo(); Assert.AreEqual(24, value); } @@ -222,18 +224,12 @@ public void CountIfs_SingleCondition() [TestCase(@"=COUNTIFS(Data!E1:E44, """")", 1)] public void CountIfs_SingleConditionWithWildcards(string formula, int expectedResult) { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); - int value = ws.Evaluate(formula).CastTo(); + var value = ws.Evaluate(formula).CastTo(); Assert.AreEqual(expectedResult, value); } - [OneTimeTearDown] - public void Dispose() - { - workbook.Dispose(); - } - [TestCase(@"H3:H45", ExpectedResult = 7.51126069234216)] [TestCase(@"H:H", ExpectedResult = 7.51126069234216)] [TestCase(@"Data!H:H", ExpectedResult = 7.51126069234216)] @@ -247,28 +243,21 @@ public void Dispose() [DefaultFloatingPointTolerance(1e-12)] public double Geomean(string sourceValue) { - return workbook.Worksheets.First().Evaluate($"=GEOMEAN({sourceValue})").CastTo(); + using var wb = SetupWorkbook(); + return wb.Worksheets.First().Evaluate($"=GEOMEAN({sourceValue})").CastTo(); } [TestCase("D3:D45", typeof(NumberException), "No numeric parameters.")] [TestCase("-1, 0, 3", typeof(NumberException), "Incorrect parameters. Use only positive numbers in your data.")] public void Geomean_IncorrectCases(string sourceValue, Type exceptionType, string exceptionMessage) { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); Assert.Throws( Is.TypeOf(exceptionType).And.Message.EqualTo(exceptionMessage), () => ws.Evaluate($"=GEOMEAN({sourceValue})")); } - [SetUp] - public void Init() - { - // Make sure tests run on a deterministic culture - System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); - workbook = SetupWorkbook(); - } - [TestCase(@"H3:H45", ExpectedResult = 94145.5271162791)] [TestCase(@"H:H", ExpectedResult = 94145.5271162791)] [TestCase(@"Data!H:H", ExpectedResult = 94145.5271162791)] @@ -282,13 +271,14 @@ public void Init() [DefaultFloatingPointTolerance(1e-10)] public double DevSq(string sourceValue) { - return workbook.Worksheets.First().Evaluate($"=DEVSQ({sourceValue})").CastTo(); + using var wb = SetupWorkbook(); + return wb.Worksheets.First().Evaluate($"=DEVSQ({sourceValue})").CastTo(); } [TestCase("D3:D45", typeof(CellValueException), "No numeric parameters.")] public void Devsq_IncorrectCases(string sourceValue, Type exceptionType, string exceptionMessage) { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); Assert.Throws( Is.TypeOf(exceptionType).And.Message.EqualTo(exceptionMessage), @@ -308,6 +298,8 @@ public void Devsq_IncorrectCases(string sourceValue, Type exceptionType, string [DefaultFloatingPointTolerance(1e-12)] public double Fisher(double sourceValue) { + using var wb = SetupWorkbook(); + return XLWorkbook.EvaluateExpr($"=FISHER({sourceValue})").CastTo(); } @@ -326,7 +318,7 @@ public void Fisher_IncorrectCases(string sourceValue, Type exceptionType, string [Test] public void Max() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=MAX(D3:D45)").CastTo(); Assert.AreEqual(0, value); @@ -337,14 +329,77 @@ public void Max() value = ws.Evaluate(@"=MAX(G:G)").CastTo(); Assert.AreEqual(96, value); - value = workbook.Evaluate(@"=MAX(Data!G:G)").CastTo(); + value = wb.Evaluate(@"=MAX(Data!G:G)").CastTo(); Assert.AreEqual(96, value); } + [Test] + public void Median_CellRangeOfNonNumericValues_ThrowsApplicationException() + { + //Arrange + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); + + //Act - Assert + Assert.Throws(() => + { + ws.Evaluate("AVERAGE(D3:D45)"); + }); + } + + [Test] + public void Median_EvenCountOfCellRange_ReturnsAverageOfTwoElementsInMiddleOfSortedList() + { + //Arrange + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); + + //Act + var value = ws.Evaluate("MEDIAN(I3:I10)").CastTo(); + + //Assert + Assert.AreEqual(244.225, value, tolerance); + } + + [Test] + public void Median_EvenCountOfManualNumbers_ReturnsAverageOfTwoElementsInMiddleOfSortedList() + { + using var wb = SetupWorkbook(); + + //Act + var value = wb.Evaluate("MEDIAN(-27.5,93.93,64.51,-70.56)").CastTo(); + + //Assert + Assert.AreEqual(18.505, value, tolerance); + } + + [Test] + public void Median_OddCountOfCellRange_ReturnsElementInMiddleOfSortedList() + { + //Arrange + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); + + //Act + var value = ws.Evaluate("MEDIAN(I3:I11)").CastTo(); + + //Assert + Assert.AreEqual(189.05, value, tolerance); + } + + [Test] + public void Median_OddCountOfManualNumbers_ReturnsElementInMiddleOfSortedList() + { + using var wb = SetupWorkbook(); + + //Act + var value = wb.Evaluate("MEDIAN(-27.5,93.93,64.51,-70.56,101.65)").CastTo(); + + //Assert + Assert.AreEqual(64.51, value, tolerance); + } + [Test] public void Min() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); int value; value = ws.Evaluate(@"=MIN(D3:D45)").CastTo(); Assert.AreEqual(0, value); @@ -355,14 +410,14 @@ public void Min() value = ws.Evaluate(@"=MIN(G:G)").CastTo(); Assert.AreEqual(2, value); - value = workbook.Evaluate(@"=MIN(Data!G:G)").CastTo(); + value = wb.Evaluate(@"=MIN(Data!G:G)").CastTo(); Assert.AreEqual(2, value); } [Test] public void StDev() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); double value; Assert.That(() => ws.Evaluate(@"=STDEV(D3:D45)"), Throws.TypeOf()); @@ -372,14 +427,14 @@ public void StDev() value = ws.Evaluate(@"=STDEV(H:H)").CastTo(); Assert.AreEqual(47.34511769, value, tolerance); - value = workbook.Evaluate(@"=STDEV(Data!H:H)").CastTo(); + value = wb.Evaluate(@"=STDEV(Data!H:H)").CastTo(); Assert.AreEqual(47.34511769, value, tolerance); } [Test] public void StDevP() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); double value; Assert.That(() => ws.Evaluate(@"=STDEVP(D3:D45)"), Throws.InvalidOperationException); @@ -389,7 +444,7 @@ public void StDevP() value = ws.Evaluate(@"=STDEVP(H:H)").CastTo(); Assert.AreEqual(46.79135458, value, tolerance); - value = workbook.Evaluate(@"=STDEVP(Data!H:H)").CastTo(); + value = wb.Evaluate(@"=STDEVP(Data!H:H)").CastTo(); Assert.AreEqual(46.79135458, value, tolerance); } @@ -405,7 +460,7 @@ public void SumIf_MixedData(string formula, double expected) // We follow to Excel's convention. // Excel treats 1 and TRUE as unequal, but 3 and "3" as equal // LibreOffice Calc handles some SUMIF and COUNTIF differently, e.g. it treats 1 and TRUE as equal, but 3 and "3" differently - var ws = workbook.Worksheet("MixedData"); + using var wb = SetupWorkbook(); var ws = wb.Worksheet("MixedData"); Assert.AreEqual(expected, ws.Evaluate(formula)); } @@ -423,26 +478,24 @@ public void SumIf_MixedData(string formula, double expected) [TestCase("SUMIFS(H:H,G:G,50,I:I,\">900\")", 19.99d, Description = "SUMIFS columns")] public void TallySkipsEmptyCells(string formulaA1, double expectedResult) { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); - //Let's pre-initialize cells we need so they didn't affect the result - ws.Range("A1:J45").Style.Fill.BackgroundColor = XLColor.Amber; - ws.Cell("ZZ1000").Value = 1; - int initialCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - - var actualResult = (double)ws.Evaluate(formulaA1); - int cellsCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - - Assert.AreEqual(expectedResult, actualResult, tolerance); - Assert.AreEqual(initialCount, cellsCount); - } + using var wb = SetupWorkbook(); + var ws = wb.Worksheets.First(); + //Let's pre-initialize cells we need so they didn't affect the result + ws.Range("A1:J45").Style.Fill.BackgroundColor = XLColor.Amber; + ws.Cell("ZZ1000").Value = 1; + var initialCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + + var actualResult = (double)ws.Evaluate(formulaA1); + var cellsCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + + Assert.AreEqual(expectedResult, actualResult, tolerance); + Assert.AreEqual(initialCount, cellsCount); } [Test] public void Var() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); double value; Assert.That(() => ws.Evaluate(@"=VAR(D3:D45)"), Throws.InvalidOperationException); @@ -452,14 +505,14 @@ public void Var() value = ws.Evaluate(@"=VAR(H:H)").CastTo(); Assert.AreEqual(2241.560169, value, tolerance); - value = workbook.Evaluate(@"=VAR(Data!H:H)").CastTo(); + value = wb.Evaluate(@"=VAR(Data!H:H)").CastTo(); Assert.AreEqual(2241.560169, value, tolerance); } [Test] public void VarP() { - var ws = workbook.Worksheets.First(); + using var wb = SetupWorkbook(); var ws = wb.Worksheets.First(); double value; Assert.That(() => ws.Evaluate(@"=VARP(D3:D45)"), Throws.InvalidOperationException); @@ -469,7 +522,7 @@ public void VarP() value = ws.Evaluate(@"=VARP(H:H)").CastTo(); Assert.AreEqual(2189.430863, value, tolerance); - value = workbook.Evaluate(@"=VARP(Data!H:H)").CastTo(); + value = wb.Evaluate(@"=VARP(Data!H:H)").CastTo(); Assert.AreEqual(2189.430863, value, tolerance); } @@ -535,4 +588,4 @@ private XLWorkbook SetupWorkbook() return wb; } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/CalcEngine/TextTests.cs b/ClosedXML.Tests/Excel/CalcEngine/TextTests.cs index e715f5b17..4217efe51 100644 --- a/ClosedXML.Tests/Excel/CalcEngine/TextTests.cs +++ b/ClosedXML.Tests/Excel/CalcEngine/TextTests.cs @@ -33,21 +33,21 @@ public void Char_Input_Too_Large() [Test] public void Char_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Char(97)"); + var actual = XLWorkbook.EvaluateExpr(@"Char(97)"); Assert.AreEqual("a", actual); } [Test] public void Clean_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Clean("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Clean("""")"); Assert.AreEqual("", actual); } [Test] public void Clean_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Clean(CHAR(9)&""Monthly report""&CHAR(10))"); + var actual = XLWorkbook.EvaluateExpr(@"Clean(CHAR(9)&""Monthly report""&CHAR(10))"); Assert.AreEqual("Monthly report", actual); actual = XLWorkbook.EvaluateExpr(@"Clean("" "")"); @@ -64,7 +64,7 @@ public void Code_Empty_Input_String() [Test] public void Code_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Code(""A"")"); + var actual = XLWorkbook.EvaluateExpr(@"Code(""A"")"); Assert.AreEqual(65, actual); actual = XLWorkbook.EvaluateExpr(@"Code(""BCD"")"); @@ -74,13 +74,14 @@ public void Code_Value() [Test] public void Concat_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Concat(""ABC"", ""123"")"); + var actual = XLWorkbook.EvaluateExpr(@"Concat(""ABC"", ""123"")"); Assert.AreEqual("ABC123", actual); actual = XLWorkbook.EvaluateExpr(@"Concat("""", ""123"")"); Assert.AreEqual("123", actual); - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); ws.FirstCell().SetValue(20) .CellBelow().SetValue("AB") @@ -100,7 +101,7 @@ public void Concat_EmptyValue() [Test] public void Concatenate_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Concatenate(""ABC"", ""123"")"); + var actual = XLWorkbook.EvaluateExpr(@"Concatenate(""ABC"", ""123"")"); Assert.AreEqual("ABC123", actual); actual = XLWorkbook.EvaluateExpr(@"Concatenate("""", ""123"")"); @@ -114,7 +115,8 @@ public void Concatenate_Value() // If we can solve ROW(), then we can solve this too. // For the example below, the calling cell doesn't share any - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); ws.FirstCell().SetValue(20) .CellBelow().SetValue("AB") @@ -140,7 +142,8 @@ public void Concatenate_Value() [Test] public void Concatenate_with_references() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); ws.Cell("A1").Value = "Hello"; ws.Cell("B1").Value = "World"; @@ -158,7 +161,7 @@ public void Dollar_Empty_Input_String() [Test] public void Dollar_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Dollar(123.54)"); + var actual = XLWorkbook.EvaluateExpr(@"Dollar(123.54)"); Assert.AreEqual("$123.54", actual); actual = XLWorkbook.EvaluateExpr(@"Dollar(123.54, 3)"); @@ -168,14 +171,14 @@ public void Dollar_Value() [Test] public void Exact_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Exact("""", """")"); + var actual = XLWorkbook.EvaluateExpr(@"Exact("""", """")"); Assert.AreEqual(true, actual); } [Test] public void Exact_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Exact(""asdf"", ""asdf"")"); + var actual = XLWorkbook.EvaluateExpr(@"Exact(""asdf"", ""asdf"")"); Assert.AreEqual(true, actual); actual = XLWorkbook.EvaluateExpr(@"Exact(""asdf"", ""ASDF"")"); @@ -216,7 +219,7 @@ public void Find_Case_Sensitive_String_Not_Found() [Test] public void Find_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Find(""Tuesday"", ""Today is Tuesday"")"); + var actual = XLWorkbook.EvaluateExpr(@"Find(""Tuesday"", ""Today is Tuesday"")"); Assert.AreEqual(10, actual); actual = XLWorkbook.EvaluateExpr(@"Find("""", """")"); @@ -229,13 +232,13 @@ public void Find_Value() [Test] public void Fixed_Input_Is_String() { - Assert.That(() => XLWorkbook.EvaluateExpr(@"Fixed(""asdf"")"), Throws.TypeOf()); + Assert.That(() => XLWorkbook.EvaluateExpr(@"Fixed(""asdf"")"), Throws.TypeOf()); } [Test] public void Fixed_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Fixed(17300.67, 4)"); + var actual = XLWorkbook.EvaluateExpr(@"Fixed(17300.67, 4)"); Assert.AreEqual("17,300.6700", actual); actual = XLWorkbook.EvaluateExpr(@"Fixed(17300.67, 2, TRUE)"); @@ -248,84 +251,84 @@ public void Fixed_Value() [Test] public void Left_Bigger_Than_Length() { - Object actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"", 5)"); + var actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"", 5)"); Assert.AreEqual("ABC", actual); } [Test] public void Left_Default() { - Object actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"")"); + var actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"")"); Assert.AreEqual("A", actual); } [Test] public void Left_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Left("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Left("""")"); Assert.AreEqual("", actual); } [Test] public void Left_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"", 2)"); + var actual = XLWorkbook.EvaluateExpr(@"Left(""ABC"", 2)"); Assert.AreEqual("AB", actual); } [Test] public void Len_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Len("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Len("""")"); Assert.AreEqual(0, actual); } [Test] public void Len_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Len(""word"")"); + var actual = XLWorkbook.EvaluateExpr(@"Len(""word"")"); Assert.AreEqual(4, actual); } [Test] public void Lower_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Lower("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Lower("""")"); Assert.AreEqual("", actual); } [Test] public void Lower_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Lower(""AbCdEfG"")"); + var actual = XLWorkbook.EvaluateExpr(@"Lower(""AbCdEfG"")"); Assert.AreEqual("abcdefg", actual); } [Test] public void Mid_Bigger_Than_Length() { - Object actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 1, 5)"); + var actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 1, 5)"); Assert.AreEqual("ABC", actual); } [Test] public void Mid_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Mid("""", 1, 1)"); + var actual = XLWorkbook.EvaluateExpr(@"Mid("""", 1, 1)"); Assert.AreEqual("", actual); } [Test] public void Mid_Start_After() { - Object actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 5, 5)"); + var actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 5, 5)"); Assert.AreEqual("", actual); } [Test] public void Mid_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 2, 2)"); + var actual = XLWorkbook.EvaluateExpr(@"Mid(""ABC"", 2, 2)"); Assert.AreEqual("BC", actual); } @@ -364,55 +367,59 @@ public void NumberValue_Correct(string expression, double expectedResult) [TestCase("NUMBERVALUE(\"-1.234567890E-310\")")] // Too tiny (negative) public void NumberValue_Invalid(string expression) { - TestDelegate action = () => XLWorkbook.EvaluateExpr(expression); + void action() + { + XLWorkbook.EvaluateExpr(expression); + } + Assert.Throws(action); } [Test] public void Proper_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Proper("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Proper("""")"); Assert.AreEqual("", actual); } [Test] public void Proper_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Proper(""my name is francois botha"")"); + var actual = XLWorkbook.EvaluateExpr(@"Proper(""my name is francois botha"")"); Assert.AreEqual("My Name Is Francois Botha", actual); } [Test] public void Replace_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Replace("""", 1, 1, ""newtext"")"); + var actual = XLWorkbook.EvaluateExpr(@"Replace("""", 1, 1, ""newtext"")"); Assert.AreEqual("newtext", actual); } [Test] public void Replace_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Replace(""Here is some obsolete text to replace."", 14, 13, ""new text"")"); + var actual = XLWorkbook.EvaluateExpr(@"Replace(""Here is some obsolete text to replace."", 14, 13, ""new text"")"); Assert.AreEqual("Here is some new text to replace.", actual); } [Test] public void Rept_Empty_Input_Strings() { - Object actual = XLWorkbook.EvaluateExpr(@"Rept("""", 3)"); + var actual = XLWorkbook.EvaluateExpr(@"Rept("""", 3)"); Assert.AreEqual("", actual); } [Test] public void Rept_Start_Is_Negative() { - Assert.That(() => XLWorkbook.EvaluateExpr(@"Rept(""Francois"", -1)"), Throws.TypeOf()); + Assert.That(() => XLWorkbook.EvaluateExpr(@"Rept(""Francois"", -1)"), Throws.TypeOf()); } [Test] public void Rept_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Rept(""Francois Botha,"", 3)"); + var actual = XLWorkbook.EvaluateExpr(@"Rept(""Francois Botha,"", 3)"); Assert.AreEqual("Francois Botha,Francois Botha,Francois Botha,", actual); actual = XLWorkbook.EvaluateExpr(@"Rept(""123"", 5/2)"); @@ -425,28 +432,28 @@ public void Rept_Value() [Test] public void Right_Bigger_Than_Length() { - Object actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"", 5)"); + var actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"", 5)"); Assert.AreEqual("ABC", actual); } [Test] public void Right_Default() { - Object actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"")"); + var actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"")"); Assert.AreEqual("C", actual); } [Test] public void Right_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Right("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Right("""")"); Assert.AreEqual("", actual); } [Test] public void Right_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"", 2)"); + var actual = XLWorkbook.EvaluateExpr(@"Right(""ABC"", 2)"); Assert.AreEqual("BC", actual); } @@ -459,7 +466,7 @@ public void Search_No_Parameters_With_Values() [Test] public void Search_Empty_Search_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Search("""", ""asdf"")"); + var actual = XLWorkbook.EvaluateExpr(@"Search("""", ""asdf"")"); Assert.AreEqual(1, actual); } @@ -497,7 +504,7 @@ public void Search_Start_Position_Too_Large2() [Test] public void Search_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Search(""Tuesday"", ""Today is Tuesday"")"); + var actual = XLWorkbook.EvaluateExpr(@"Search(""Tuesday"", ""Today is Tuesday"")"); Assert.AreEqual(10, actual); // Find is case-INsensitive @@ -517,7 +524,7 @@ public void Search_Value() [Test] public void Substitute_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Substitute(""This is a Tuesday."", ""Tuesday"", ""Monday"")"); + var actual = XLWorkbook.EvaluateExpr(@"Substitute(""This is a Tuesday."", ""Tuesday"", ""Monday"")"); Assert.AreEqual("This is a Monday.", actual); actual = XLWorkbook.EvaluateExpr(@"Substitute(""This is a Tuesday. Next week also has a Tuesday."", ""Tuesday"", ""Monday"", 1)"); @@ -539,14 +546,14 @@ public void Substitute_Value() [Test] public void T_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"T("""")"); + var actual = XLWorkbook.EvaluateExpr(@"T("""")"); Assert.AreEqual("", actual); } [Test] public void T_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"T(""asdf"")"); + var actual = XLWorkbook.EvaluateExpr(@"T(""asdf"")"); Assert.AreEqual("asdf", actual); actual = XLWorkbook.EvaluateExpr(@"T(Today())"); @@ -559,14 +566,14 @@ public void T_Value() [Test] public void Text_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Text(1913415.93, """")"); + var actual = XLWorkbook.EvaluateExpr(@"Text(1913415.93, """")"); Assert.AreEqual("", actual); } [Test] public void Text_Value() { - Object actual; + object actual; actual = XLWorkbook.EvaluateExpr(@"Text(Date(2010, 1, 1), ""yyyy-MM-dd"")"); Assert.AreEqual("2010-01-01", actual); @@ -592,7 +599,7 @@ public void Text_Value() [Test] public void Text_String_Input() { - Object actual = XLWorkbook.EvaluateExpr(@"TEXT(""211x"", ""#00"")"); + var actual = XLWorkbook.EvaluateExpr(@"TEXT(""211x"", ""#00"")"); Assert.AreEqual("211x", actual); } @@ -613,8 +620,8 @@ public void Text_String_Input() [TestCase("=TEXTJOIN(\",\", \"0\", A1:B2)", "A,,B,D")] // Excel does not accept text argument, LibreOffice does public void TextJoin(string formula, string expectedOutput) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "A"; ws.Cell("A2").Value = "B"; ws.Cell("B1").Value = ""; @@ -630,15 +637,15 @@ public void TextJoin(string formula, string expectedOutput) [TestCase("=TEXTJOIN(\",\", \"Invalid\", A1:B2)", "The second argument is invalid")] public void TextJoinWithInvalidArgumentsThrows(string formula, string explain) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("C1").FormulaA1 = formula; - TestDelegate action = () => + void action() { var a = ws.Cell("C1").Value; - }; + } Assert.Throws(action, explain); } @@ -658,28 +665,28 @@ public void Text_DateFormats(int year, int months, int days, int hour, int minut [Test] public void Trim_EmptyInput_Striong() { - Object actual = XLWorkbook.EvaluateExpr(@"Trim("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Trim("""")"); Assert.AreEqual("", actual); } [Test] public void Trim_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Trim("" some text with padding "")"); + var actual = XLWorkbook.EvaluateExpr(@"Trim("" some text with padding "")"); Assert.AreEqual("some text with padding", actual); } [Test] public void Upper_Empty_Input_String() { - Object actual = XLWorkbook.EvaluateExpr(@"Upper("""")"); + var actual = XLWorkbook.EvaluateExpr(@"Upper("""")"); Assert.AreEqual("", actual); } [Test] public void Upper_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Upper(""AbCdEfG"")"); + var actual = XLWorkbook.EvaluateExpr(@"Upper(""AbCdEfG"")"); Assert.AreEqual("ABCDEFG", actual); } @@ -692,11 +699,11 @@ public void Value_Input_String_Is_Not_A_Number() [Test] public void Value_Value() { - Object actual = XLWorkbook.EvaluateExpr(@"Value(""123.54"")"); + var actual = XLWorkbook.EvaluateExpr(@"Value(""123.54"")"); Assert.AreEqual(123.54, actual); actual = XLWorkbook.EvaluateExpr(@"Value(654.32)"); Assert.AreEqual(654.32, actual); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Cells/DataTypeTests.cs b/ClosedXML.Tests/Excel/Cells/DataTypeTests.cs index 26d2d8a3e..c053b81a3 100644 --- a/ClosedXML.Tests/Excel/Cells/DataTypeTests.cs +++ b/ClosedXML.Tests/Excel/Cells/DataTypeTests.cs @@ -10,13 +10,11 @@ public class DataTypeTests [Test] public void ConvertNonNumericTextToNumberThrowsException() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - var c = ws.Cell("A1"); - c.Value = "ABC123"; - Assert.Throws(() => c.DataType = XLDataType.Number); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var c = ws.Cell("A1"); + c.Value = "ABC123"; + Assert.Throws(() => c.DataType = XLDataType.Number); } } } diff --git a/ClosedXML.Tests/Excel/Cells/XLCellTests.cs b/ClosedXML.Tests/Excel/Cells/XLCellTests.cs index 2c7037822..dc595aae8 100644 --- a/ClosedXML.Tests/Excel/Cells/XLCellTests.cs +++ b/ClosedXML.Tests/Excel/Cells/XLCellTests.cs @@ -8,7 +8,7 @@ using System.Linq; using System.Threading; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Cells { [TestFixture] public class XLCellTests @@ -16,17 +16,18 @@ public class XLCellTests [Test] public void CellsUsed() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Cell(1, 1); ws.Cell(2, 2); - int count = ws.Range("A1:B2").CellsUsed().Count(); + var count = ws.Range("A1:B2").CellsUsed().Count(); Assert.AreEqual(0, count); } [Test] public void CellsUsedIncludeStyles1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Row(3).Style.Fill.BackgroundColor = XLColor.Red; ws.Column(3).Style.Fill.BackgroundColor = XLColor.Red; ws.Cell(2, 2).Value = "ASDF"; @@ -37,7 +38,8 @@ public void CellsUsedIncludeStyles1() [Test] public void CellsUsedIncludeStyles2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Row(2).Style.Fill.BackgroundColor = XLColor.Red; ws.Column(2).Style.Fill.BackgroundColor = XLColor.Red; ws.Cell(3, 3).Value = "ASDF"; @@ -48,7 +50,8 @@ public void CellsUsedIncludeStyles2() [Test] public void CellsUsedIncludeStyles3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); var range = ws.RangeUsed(XLCellsUsedOptions.All); Assert.AreEqual(null, range); } @@ -56,21 +59,25 @@ public void CellsUsedIncludeStyles3() [Test] public void CellUsedIncludesSparklines() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:E4").Value = 1; ws.SparklineGroups.Add("B2", "C3:E3"); ws.SparklineGroups.Add("F5", "C4:E4"); +#pragma warning disable CS0618 // Type or member is obsolete, but still should be tested var range = ws.RangeUsed(true).RangeAddress.ToString(); +#pragma warning restore CS0618 // Type or member is obsolete, but still should be tested Assert.AreEqual("B2:F5", range); } [Test] public void Double_Infinity_is_a_string() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1"); - var doubleList = new List { 1.0 / 0.0 }; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + var doubleList = new List { 1.0 / 0.0 }; cell.Value = 5; cell.Value = doubleList; @@ -86,9 +93,10 @@ public void Double_Infinity_is_a_string() [Test] public void Double_NaN_is_a_string() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1"); - var doubleList = new List { 0.0 / 0.0 }; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + var doubleList = new List { 0.0 / 0.0 }; cell.Value = 5; cell.Value = doubleList; @@ -104,43 +112,63 @@ public void Double_NaN_is_a_string() [Test] public void GetValue_Nullable() { - var cell = new XLWorkbook().AddWorksheet().FirstCell(); + var backupCulture = Thread.CurrentThread.CurrentCulture; - Assert.IsNull(cell.Clear().GetValue()); - Assert.AreEqual(1.5, cell.SetValue(1.5).GetValue()); - Assert.AreEqual(2, cell.SetValue(1.5).GetValue()); - Assert.AreEqual(2.5, cell.SetValue("2.5").GetValue()); - Assert.Throws(() => cell.SetValue("text").GetValue()); + // Set thread culture to French, which should format numbers using a space as thousands separator + try + { + var culture = CultureInfo.CreateSpecificCulture("fr-FR"); + // but use a period instead of a comma as for decimal separator + culture.NumberFormat.CurrencyDecimalSeparator = "."; + Thread.CurrentThread.CurrentCulture = culture; + + using var xLWorkbook = new XLWorkbook(); + var cell = xLWorkbook.AddWorksheet().FirstCell(); + + Assert.IsNull(cell.Clear().GetValue()); + Assert.AreEqual(1.5, cell.SetValue(1.5).GetValue()); + Assert.AreEqual(2, cell.SetValue(1.5).GetValue()); + Assert.AreEqual(2.5, cell.SetValue("2.5").GetValue()); + Assert.Throws(() => cell.SetValue("text").GetValue()); + } + finally + { + Thread.CurrentThread.CurrentCulture = backupCulture; + } } [Test] public void InsertData1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRange range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }); Assert.AreEqual("Sheet1!B2:B4", range.ToString()); } [Test] public void InsertData2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRange range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }, false); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }, false); Assert.AreEqual("Sheet1!B2:B4", range.ToString()); } [Test] public void InsertData3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRange range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }, true); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var range = ws.Cell(2, 2).InsertData(new[] { "a", "b", "c" }, true); Assert.AreEqual("Sheet1!B2:D2", range.ToString()); } [Test] public void InsertData_with_Guids() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.FirstCell().InsertData(Enumerable.Range(1, 20).Select(i => new { Guid = Guid.NewGuid() })); Assert.AreEqual(XLDataType.Text, ws.FirstCell().DataType); @@ -150,10 +178,13 @@ public void InsertData_with_Guids() [Test] public void InsertData_with_Nulls() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); - var table = new DataTable(); - table.TableName = "Patients"; + using var table = new DataTable + { + TableName = "Patients" + }; table.Columns.Add("Dosage", typeof(int)); table.Columns.Add("Drug", typeof(string)); table.Columns.Add("Patient", typeof(string)); @@ -175,7 +206,8 @@ public void InsertData_with_Nulls() [Test] public void InsertData_with_Nulls_IEnumerable() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); var dateTimeList = new List() { @@ -189,78 +221,260 @@ public void InsertData_with_Nulls_IEnumerable() ws.FirstCell().InsertData(dateTimeList); Assert.AreEqual(new DateTime(2000, 1, 1), ws.Cell("A1").GetDateTime()); - Assert.AreEqual(String.Empty, ws.Cell("A5").Value); + Assert.AreEqual(string.Empty, ws.Cell("A5").Value); } [Test] public void IsEmpty1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - bool actual = cell.IsEmpty(); - bool expected = true; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var actual = cell.IsEmpty(); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - bool actual = cell.IsEmpty(XLCellsUsedOptions.All); - bool expected = true; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var actual = cell.IsEmpty(XLCellsUsedOptions.All); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - bool actual = cell.IsEmpty(); - bool expected = true; + var actual = cell.IsEmpty(); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty4() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - bool actual = cell.IsEmpty(XLCellsUsedOptions.AllContents); - bool expected = true; + var actual = cell.IsEmpty(XLCellsUsedOptions.AllContents); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty5() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - bool actual = cell.IsEmpty(XLCellsUsedOptions.All); - bool expected = false; + var actual = cell.IsEmpty(XLCellsUsedOptions.All); + var expected = false; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty6() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Value = "X"; - bool actual = cell.IsEmpty(); - bool expected = false; + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_Comment() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.GetComment().AddText("comment"); + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_Comment_Value() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.GetComment().AddText("comment"); + cell.SetValue("value"); + + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + [TestCase(XLCellsUsedOptions.Contents, true)] + [TestCase(XLCellsUsedOptions.DataType, true)] + [TestCase(XLCellsUsedOptions.NormalFormats, true)] + [TestCase(XLCellsUsedOptions.ConditionalFormats, true)] + [TestCase(XLCellsUsedOptions.Comments, false)] + [TestCase(XLCellsUsedOptions.DataValidation, true)] + [TestCase(XLCellsUsedOptions.MergedRanges, true)] + [TestCase(XLCellsUsedOptions.Sparklines, true)] + [TestCase(XLCellsUsedOptions.AllFormats, true)] + [TestCase(XLCellsUsedOptions.AllContents, false)] + [TestCase(XLCellsUsedOptions.All, false)] + public void IsEmpty_Comment_Options(XLCellsUsedOptions options, bool expected) + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.GetComment().AddText("comment"); + + var actual = cell.IsEmpty(options); + + Assert.AreEqual(expected, actual); + } + + [Test] + [TestCase(XLCellsUsedOptions.Contents, false)] + [TestCase(XLCellsUsedOptions.DataType, true)] + [TestCase(XLCellsUsedOptions.NormalFormats, true)] + [TestCase(XLCellsUsedOptions.ConditionalFormats, true)] + [TestCase(XLCellsUsedOptions.Comments, false)] + [TestCase(XLCellsUsedOptions.DataValidation, true)] + [TestCase(XLCellsUsedOptions.MergedRanges, true)] + [TestCase(XLCellsUsedOptions.Sparklines, true)] + [TestCase(XLCellsUsedOptions.AllFormats, true)] + [TestCase(XLCellsUsedOptions.AllContents, false)] + [TestCase(XLCellsUsedOptions.All, false)] + public void IsEmpty_Comment_Options_Value(XLCellsUsedOptions options, bool expected) // see #1575 + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.GetComment().AddText("comment"); + cell.SetValue("value"); + + var actual = cell.IsEmpty(options); + + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_DataType() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Boolean; + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_DataType_Text() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Text; + var actual = cell.IsEmpty(); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_DataType_Value() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Number; + cell.SetValue(42); + + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + public void IsEmpty_DataType_Text_Value() + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Text; + cell.SetValue("value"); + + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [Test] + [TestCase(XLCellsUsedOptions.Contents, true)] + [TestCase(XLCellsUsedOptions.DataType, false)] + [TestCase(XLCellsUsedOptions.NormalFormats, true)] + [TestCase(XLCellsUsedOptions.ConditionalFormats, true)] + [TestCase(XLCellsUsedOptions.Comments, true)] + [TestCase(XLCellsUsedOptions.DataValidation, true)] + [TestCase(XLCellsUsedOptions.MergedRanges, true)] + [TestCase(XLCellsUsedOptions.Sparklines, true)] + [TestCase(XLCellsUsedOptions.AllFormats, true)] + [TestCase(XLCellsUsedOptions.AllContents, false)] + [TestCase(XLCellsUsedOptions.All, false)] + public void IsEmpty_DataType_Options(XLCellsUsedOptions options, bool expected) + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Number; + + var actual = cell.IsEmpty(options); + + Assert.AreEqual(expected, actual); + } + + [Test] + [TestCase(XLCellsUsedOptions.Contents, false)] + [TestCase(XLCellsUsedOptions.DataType, false)] + [TestCase(XLCellsUsedOptions.NormalFormats, true)] + [TestCase(XLCellsUsedOptions.ConditionalFormats, true)] + [TestCase(XLCellsUsedOptions.Comments, true)] + [TestCase(XLCellsUsedOptions.DataValidation, true)] + [TestCase(XLCellsUsedOptions.MergedRanges, true)] + [TestCase(XLCellsUsedOptions.Sparklines, true)] + [TestCase(XLCellsUsedOptions.AllFormats, true)] + [TestCase(XLCellsUsedOptions.AllContents, false)] + [TestCase(XLCellsUsedOptions.All, false)] + public void IsEmpty_DataType_Options_Value(XLCellsUsedOptions options, bool expected) // see #1575 + { + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.DataType = XLDataType.Number; + cell.SetValue(42); + + var actual = cell.IsEmpty(options); + Assert.AreEqual(expected, actual); } [Test] public void NaN_is_not_a_number() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); cell.Value = "NaN"; Assert.AreNotEqual(XLDataType.Number, cell.DataType); @@ -269,8 +483,9 @@ public void NaN_is_not_a_number() [Test] public void Nan_is_not_a_number() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1"); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); cell.Value = "Nan"; Assert.AreNotEqual(XLDataType.Number, cell.DataType); @@ -279,18 +494,20 @@ public void Nan_is_not_a_number() [Test] public void TryGetValue_Boolean_Bad() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue("ABC"); - bool success = cell.TryGetValue(out bool outValue); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue("ABC"); + var success = cell.TryGetValue(out bool outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_Boolean_False() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue(false); - bool success = cell.TryGetValue(out bool outValue); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue(false); + var success = cell.TryGetValue(out bool outValue); Assert.IsTrue(success); Assert.IsFalse(outValue); } @@ -298,9 +515,9 @@ public void TryGetValue_Boolean_False() [Test] public void TryGetValue_Boolean_Good() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue("True"); - bool success = cell.TryGetValue(out bool outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue("true"); + var success = cell.TryGetValue(out bool outValue); Assert.IsTrue(success); Assert.IsTrue(outValue); } @@ -308,9 +525,9 @@ public void TryGetValue_Boolean_Good() [Test] public void TryGetValue_Boolean_True() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue(true); - bool success = cell.TryGetValue(out bool outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue(true); + var success = cell.TryGetValue(out bool outValue); Assert.IsTrue(success); Assert.IsTrue(outValue); } @@ -318,9 +535,9 @@ public void TryGetValue_Boolean_True() [Test] public void TryGetValue_DateTime_Good() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var date = "2018-01-01"; - bool success = ws.Cell("A1").SetValue(date).TryGetValue(out DateTime outValue); + var success = ws.Cell("A1").SetValue(date).TryGetValue(out DateTime outValue); Assert.IsTrue(success); Assert.AreEqual(new DateTime(2018, 1, 1), outValue); } @@ -328,8 +545,8 @@ public void TryGetValue_DateTime_Good() [Test] public void TryGetValue_DateTime_Good2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - bool success = ws.Cell("A1").SetFormulaA1("=TODAY() + 10").TryGetValue(out DateTime outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var success = ws.Cell("A1").SetFormulaA1("=TODAY() + 10").TryGetValue(out DateTime outValue); Assert.IsTrue(success); Assert.AreEqual(DateTime.Today.AddDays(10), outValue); } @@ -337,8 +554,8 @@ public void TryGetValue_DateTime_Good2() [Test] public void TryGetValue_DateTime_BadButFormulaGood() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - bool success = ws.Cell("A1").SetFormulaA1("=\"44\"&\"020\"").TryGetValue(out DateTime outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var success = ws.Cell("A1").SetFormulaA1("=\"44\"&\"020\"").TryGetValue(out DateTime outValue); Assert.IsFalse(success); ws.Cell("B1").SetFormulaA1("=A1+1"); @@ -351,26 +568,27 @@ public void TryGetValue_DateTime_BadButFormulaGood() [Test] public void TryGetValue_DateTime_BadString() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var date = "ABC"; - bool success = ws.Cell("A1").SetValue(date).TryGetValue(out DateTime outValue); + var success = ws.Cell("A1").SetValue(date).TryGetValue(out DateTime outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_DateTime_BadString2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var date = 5545454; ws.FirstCell().SetValue(date).DataType = XLDataType.DateTime; - bool success = ws.FirstCell().TryGetValue(out DateTime outValue); + var success = ws.FirstCell().TryGetValue(out DateTime outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_Enum_Good() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); Assert.IsTrue(ws.FirstCell().SetValue(NumberStyles.AllowCurrencySymbol).TryGetValue(out NumberStyles value)); Assert.AreEqual(NumberStyles.AllowCurrencySymbol, value); @@ -382,7 +600,8 @@ public void TryGetValue_Enum_Good() [Test] public void TryGetValue_Enum_BadString() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); Assert.IsFalse(ws.FirstCell().SetValue("ABC").TryGetValue(out NumberStyles value)); Assert.IsFalse(ws.FirstCell().SetValue("ABC").TryGetValue(out NumberStyles? value2)); } @@ -390,9 +609,9 @@ public void TryGetValue_Enum_BadString() [Test] public void TryGetValue_RichText_Bad() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue("Anything"); - bool success = cell.TryGetValue(out IXLRichText outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue("Anything"); + var success = cell.TryGetValue(out IXLRichText outValue); Assert.IsTrue(success); Assert.AreEqual(cell.GetRichText(), outValue); Assert.AreEqual("Anything", outValue.ToString()); @@ -401,10 +620,10 @@ public void TryGetValue_RichText_Bad() [Test] public void TryGetValue_RichText_Good() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); cell.GetRichText().AddText("Anything"); - bool success = cell.TryGetValue(out IXLRichText outValue); + var success = cell.TryGetValue(out IXLRichText outValue); Assert.IsTrue(success); Assert.AreEqual(cell.GetRichText(), outValue); } @@ -412,18 +631,18 @@ public void TryGetValue_RichText_Good() [Test] public void TryGetValue_TimeSpan_BadString() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - string timeSpan = "ABC"; - bool success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var timeSpan = "ABC"; + var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_TimeSpan_Good() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var timeSpan = new TimeSpan(1, 1, 1); - bool success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); + var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); Assert.IsTrue(success); Assert.AreEqual(timeSpan, outValue); } @@ -431,9 +650,9 @@ public void TryGetValue_TimeSpan_Good() [Test] public void TryGetValue_TimeSpan_Good_Large() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var timeSpan = TimeSpan.FromMilliseconds((double)int.MaxValue + 1); - bool success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); + var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out TimeSpan outValue); Assert.IsTrue(success); Assert.AreEqual(timeSpan, outValue); } @@ -441,9 +660,9 @@ public void TryGetValue_TimeSpan_Good_Large() [Test] public void TryGetValue_TimeSpan_GoodString() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var timeSpan = new TimeSpan(1, 1, 1); - bool success = ws.Cell("A1").SetValue(timeSpan.ToString()).TryGetValue(out TimeSpan outValue); + var success = ws.Cell("A1").SetValue(timeSpan.ToString()).TryGetValue(out TimeSpan outValue); Assert.IsTrue(success); Assert.AreEqual(timeSpan, outValue); } @@ -451,27 +670,27 @@ public void TryGetValue_TimeSpan_GoodString() [Test] public void TryGetValue_sbyte_Bad() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue(255); - bool success = cell.TryGetValue(out sbyte outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue(255); + var success = cell.TryGetValue(out sbyte outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_sbyte_Bad2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue("255"); - bool success = cell.TryGetValue(out sbyte outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue("255"); + var success = cell.TryGetValue(out sbyte outValue); Assert.IsFalse(success); } [Test] public void TryGetValue_sbyte_Good() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue(5); - bool success = cell.TryGetValue(out sbyte outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue(5); + var success = cell.TryGetValue(out sbyte outValue); Assert.IsTrue(success); Assert.AreEqual(5, outValue); } @@ -479,9 +698,9 @@ public void TryGetValue_sbyte_Good() [Test] public void TryGetValue_sbyte_Good2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell("A1").SetValue("5"); - bool success = cell.TryGetValue(out sbyte outValue); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1").SetValue("5"); + var success = cell.TryGetValue(out sbyte outValue); Assert.IsTrue(success); Assert.AreEqual(5, outValue); } @@ -489,9 +708,9 @@ public void TryGetValue_sbyte_Good2() [Test] public void TryGetValue_decimal_Good() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var cell = ws.Cell("A1").SetValue("5"); - bool success = cell.TryGetValue(out decimal outValue); + var success = cell.TryGetValue(out decimal outValue); Assert.IsTrue(success); Assert.AreEqual(5, outValue); } @@ -501,9 +720,9 @@ public void TryGetValue_decimal_Good2() { Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US"); - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); var cell = ws.Cell("A1").SetValue("1.60000001869776E-06"); - bool success = cell.TryGetValue(out decimal outValue); + var success = cell.TryGetValue(out decimal outValue); Assert.IsTrue(success); Assert.AreEqual(1.60000001869776E-06, outValue); } @@ -511,34 +730,29 @@ public void TryGetValue_decimal_Good2() [Test] public void TryGetValue_Hyperlink() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet1"); - var ws2 = wb.Worksheets.Add("Sheet2"); + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet1"); + var ws2 = wb.Worksheets.Add("Sheet2"); - var targetCell = ws2.Cell("A1"); + var targetCell = ws2.Cell("A1"); - var linkCell1 = ws1.Cell("A1"); - linkCell1.Value = "Link to IXLCell"; - linkCell1.SetHyperlink(new XLHyperlink(targetCell)); + var linkCell1 = ws1.Cell("A1"); + linkCell1.Value = "Link to IXLCell"; + linkCell1.SetHyperlink(new XLHyperlink(targetCell)); - var success = linkCell1.TryGetValue(out XLHyperlink hyperlink); - Assert.IsTrue(success); - Assert.AreEqual("Sheet2!A1", hyperlink.InternalAddress); - } + var success = linkCell1.TryGetValue(out XLHyperlink hyperlink); + Assert.IsTrue(success); + Assert.AreEqual("Sheet2!A1", hyperlink.InternalAddress); } [Test] public void TryGetValue_Unicode_String() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); - Boolean success; - String outValue; - - success = ws.Cell("A1") - .SetValue("Site_x0020_Column_x0020_Test") - .TryGetValue(out outValue); + var success = ws.Cell("A1") + .SetValue("Site_x0020_Column_x0020_Test") + .TryGetValue(out string outValue); Assert.IsTrue(success); Assert.AreEqual("Site Column Test", outValue); @@ -553,7 +767,7 @@ public void TryGetValue_Unicode_String() [Test] public void TryGetValue_Nullable() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); ws.Cell("A1").Clear(); @@ -572,7 +786,7 @@ public void TryGetValue_Nullable() [Test] public void SetCellValueToGuid() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var guid = Guid.NewGuid(); ws.FirstCell().Value = guid; Assert.AreEqual(XLDataType.Text, ws.FirstCell().DataType); @@ -589,7 +803,7 @@ public void SetCellValueToGuid() [Test] public void SetCellValueToEnum() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var dataType = XLDataType.Number; ws.FirstCell().Value = dataType; Assert.AreEqual(XLDataType.Text, ws.FirstCell().DataType); @@ -606,7 +820,7 @@ public void SetCellValueToEnum() [Test] public void SetCellValueToRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Cell("A1").SetValue(2) .CellRight().SetValue(3) @@ -626,12 +840,12 @@ public void SetCellValueToRange() [Test] public void ValueSetToEmptyString() { - string expected = String.Empty; + var expected = string.Empty; - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Value = new DateTime(2000, 1, 2); - cell.Value = String.Empty; + cell.Value = string.Empty; Assert.AreEqual(expected, cell.GetString()); Assert.AreEqual(expected, cell.Value); @@ -644,10 +858,10 @@ public void ValueSetToEmptyString() [Test] public void ValueSetToNull() { - string expected = String.Empty; + var expected = string.Empty; - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Value = new DateTime(2000, 1, 2); cell.Value = null; Assert.AreEqual(expected, cell.GetString()); @@ -667,8 +881,8 @@ public void ValueSetDateWithShortUserDateFormat() var ci = new CultureInfo(CultureInfo.InvariantCulture.LCID); ci.DateTimeFormat.ShortDatePattern = "dd/MM/yy"; Thread.CurrentThread.CurrentCulture = ci; - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); var expected = DateTime.Today.AddYears(20); cell.Value = expected; var actual = (DateTime)cell.Value; @@ -678,47 +892,65 @@ public void ValueSetDateWithShortUserDateFormat() [Test] public void SetStringCellValues() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var cell = ws.FirstCell(); - - object expected; - - var date = new DateTime(2018, 4, 18); - expected = date.ToString(); - cell.Value = expected; - Assert.AreEqual(XLDataType.DateTime, cell.DataType); - Assert.AreEqual(date, cell.Value); - - var b = true; - expected = b.ToString(); - cell.Value = expected; - Assert.AreEqual(XLDataType.Boolean, cell.DataType); - Assert.AreEqual(b, cell.Value); - - var ts = new TimeSpan(8, 12, 4); - expected = ts.ToString(); - cell.Value = expected; - Assert.AreEqual(XLDataType.TimeSpan, cell.DataType); - Assert.AreEqual(ts, cell.Value); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var cell = ws.FirstCell(); + + object expected; + + var date = new DateTime(2018, 4, 18); + expected = date.ToString(CultureInfo.CurrentCulture); + cell.Value = expected; + Assert.AreEqual(XLDataType.DateTime, cell.DataType); + Assert.AreEqual(date, cell.Value); + + var b = true; + expected = b.ToString(CultureInfo.CurrentCulture); + cell.Value = expected; + Assert.AreEqual(XLDataType.Boolean, cell.DataType); + Assert.AreEqual(b, cell.Value); + + var ts = new TimeSpan(8, 12, 4); + expected = ts.ToString(); + cell.Value = expected; + Assert.AreEqual(XLDataType.TimeSpan, cell.DataType); + Assert.AreEqual(ts, cell.Value); } [Test] public void SetStringValueTooLong() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = new DateTime(2018, 5, 15); + ws.FirstCell().Value = new DateTime(2018, 5, 15); - ws.FirstCell().SetValue(new String('A', 32767)); + ws.FirstCell().SetValue(new string('A', 32767)); - Assert.Throws(() => ws.FirstCell().Value = new String('A', 32768)); - Assert.Throws(() => ws.FirstCell().SetValue(new String('A', 32768))); - } + Assert.Throws(() => ws.FirstCell().Value = new string('A', 32768)); + Assert.Throws(() => ws.FirstCell().SetValue(new string('A', 32768))); + } + + [Test] + [Culture("en-GB")] + public void SetDateTime_in_Regular_and_Strict_Mode() + { + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + var cell = ws.FirstCell() as XLCell; + + //Test non-strict mode + cell.SetDateValue("1/1/2000"); + + Assert.AreEqual("36526", cell.Value); + Assert.AreEqual(DateTime.Parse("1/1/2000"), DateTime.FromOADate(double.Parse(cell.Value as string))); + + //Test strict mode + cell.SetDateValue("30000"); + + Assert.AreEqual("30000", cell.Value); + Assert.AreEqual(DateTime.Parse("2/18/1982"), DateTime.FromOADate(double.Parse(cell.Value as string))); } [Test] @@ -726,61 +958,55 @@ public void SetDateOutOfRange() { Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-ZA"); - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = 5; + ws.FirstCell().Value = 5; - var date = XLCell.BaseDate.AddDays(-1); - ws.FirstCell().Value = date; + var date = XLCell.BaseDate.AddDays(-1); + ws.FirstCell().Value = date; - // Should default to string representation using current culture's date format - Assert.AreEqual(XLDataType.Text, ws.FirstCell().DataType); - Assert.AreEqual(date.ToString(), ws.FirstCell().Value); + // Should default to string representation using current culture's date format + Assert.AreEqual(XLDataType.Text, ws.FirstCell().DataType); + Assert.AreEqual(date.ToString(), ws.FirstCell().Value); - Assert.Throws(() => ws.FirstCell().SetValue(XLCell.BaseDate.AddDays(-1))); - } + Assert.Throws(() => ws.FirstCell().SetValue(XLCell.BaseDate.AddDays(-1))); } [Test] public void SetCellValueWipesFormulas() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().FormulaA1 = "=TODAY()"; - ws.FirstCell().Value = "hello world"; - Assert.IsFalse(ws.FirstCell().HasFormula); + ws.FirstCell().FormulaA1 = "=TODAY()"; + ws.FirstCell().Value = "hello world"; + Assert.IsFalse(ws.FirstCell().HasFormula); - ws.FirstCell().FormulaA1 = "=TODAY()"; - ws.FirstCell().SetValue("hello world"); - Assert.IsFalse(ws.FirstCell().HasFormula); - } + ws.FirstCell().FormulaA1 = "=TODAY()"; + ws.FirstCell().SetValue("hello world"); + Assert.IsFalse(ws.FirstCell().HasFormula); } [Test] public void CellValueLineWrapping() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = "hello world"; - Assert.IsFalse(ws.FirstCell().Style.Alignment.WrapText); + ws.FirstCell().Value = "hello world"; + Assert.IsFalse(ws.FirstCell().Style.Alignment.WrapText); - ws.FirstCell().Value = "hello\r\nworld"; - Assert.IsTrue(ws.FirstCell().Style.Alignment.WrapText); + ws.FirstCell().Value = "hello\r\nworld"; + Assert.IsTrue(ws.FirstCell().Style.Alignment.WrapText); - ws.FirstCell().Style.Alignment.WrapText = false; + ws.FirstCell().Style.Alignment.WrapText = false; - ws.FirstCell().SetValue("hello world"); - Assert.IsFalse(ws.FirstCell().Style.Alignment.WrapText); + ws.FirstCell().SetValue("hello world"); + Assert.IsFalse(ws.FirstCell().Style.Alignment.WrapText); - ws.FirstCell().SetValue("hello\r\nworld"); - Assert.IsTrue(ws.FirstCell().Style.Alignment.WrapText); - } + ws.FirstCell().SetValue("hello\r\nworld"); + Assert.IsTrue(ws.FirstCell().Style.Alignment.WrapText); } [Test] @@ -790,7 +1016,7 @@ public void TestInvalidXmlCharacters() using (var stream = new MemoryStream()) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.AddWorksheet("Sheet1").FirstCell().SetValue("\u0018"); wb.SaveAs(stream); data = stream.ToArray(); @@ -798,7 +1024,7 @@ public void TestInvalidXmlCharacters() using (var stream = new MemoryStream(data)) { - var wb = new XLWorkbook(stream); + using var wb = new XLWorkbook(stream); Assert.AreEqual("\u0018", wb.Worksheets.First().FirstCell().Value); } } @@ -806,66 +1032,62 @@ public void TestInvalidXmlCharacters() [Test] public void CanClearCellValueBySettingNullValue() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var cell = ws.FirstCell(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var cell = ws.FirstCell(); - cell.Value = "Test"; - Assert.AreEqual("Test", cell.Value); - Assert.AreEqual(XLDataType.Text, cell.DataType); + cell.Value = "Test"; + Assert.AreEqual("Test", cell.Value); + Assert.AreEqual(XLDataType.Text, cell.DataType); - string s = null; - cell.SetValue(s); - Assert.AreEqual(string.Empty, cell.Value); + string s = null; + cell.SetValue(s); + Assert.AreEqual(string.Empty, cell.Value); - cell.Value = "Test"; - cell.Value = null; - Assert.AreEqual(string.Empty, cell.Value); - } + cell.Value = "Test"; + cell.Value = null; + Assert.AreEqual(string.Empty, cell.Value); } [Test] public void CanClearDateTimeCellValue() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var c = ws.FirstCell(); - c.SetValue(new DateTime(2017, 10, 08)); - Assert.AreEqual(XLDataType.DateTime, c.DataType); - Assert.AreEqual(new DateTime(2017, 10, 08), c.Value); - - wb.SaveAs(ms); - } - - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var c = ws.FirstCell(); - Assert.AreEqual(XLDataType.DateTime, c.DataType); - Assert.AreEqual(new DateTime(2017, 10, 08), c.Value); - - c.Clear(); - wb.Save(); - } - - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var c = ws.FirstCell(); - Assert.AreEqual(XLDataType.Text, c.DataType); - Assert.True(c.IsEmpty()); - } + var ws = wb.AddWorksheet("Sheet1"); + var c = ws.FirstCell(); + c.SetValue(new DateTime(2017, 10, 08)); + Assert.AreEqual(XLDataType.DateTime, c.DataType); + Assert.AreEqual(new DateTime(2017, 10, 08), c.Value); + + wb.SaveAs(ms); + } + + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var c = ws.FirstCell(); + Assert.AreEqual(XLDataType.DateTime, c.DataType); + Assert.AreEqual(new DateTime(2017, 10, 08), c.Value); + + c.Clear(); + wb.Save(); + } + + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var c = ws.FirstCell(); + Assert.AreEqual(XLDataType.Text, c.DataType); + Assert.True(c.IsEmpty()); } } [Test] public void ClearCellRemovesSparkline() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.SparklineGroups.Add("B1:B3", "C1:E3"); ws.Cell("B1").Clear(XLClearOptions.All); @@ -881,234 +1103,221 @@ public void ClearCellRemovesSparkline() public void CurrentRegion() { // Partially based on sample in https://github.com/ClosedXML/ClosedXML/issues/120 - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + ws.Cell("B1").SetValue("x") + .CellBelow().SetValue("x") + .CellBelow().SetValue("x"); + + ws.Cell("C1").SetValue("x") + .CellBelow().SetValue("x") + .CellBelow().SetValue("x"); + + //Deliberately D2 + ws.Cell("D2").SetValue("x") + .CellBelow().SetValue("x"); + + ws.Cell("G1").SetValue("x") + .CellBelow() // skip a cell + .CellBelow().SetValue("x") + .CellBelow().SetValue("x"); + + // Deliberately H2 + ws.Cell("H2").SetValue("x") + .CellBelow().SetValue("x") + .CellBelow().SetValue("x"); + + // A diagonal + ws.Cell("E8").SetValue("x") + .CellBelow().CellRight().SetValue("x") + .CellBelow().CellRight().SetValue("x") + .CellBelow().CellRight().SetValue("x") + .CellBelow().CellRight().SetValue("x"); + + Assert.AreEqual("A10:A10", ws.Cell("A10").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("B5:B5", ws.Cell("B5").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("P1:P1", ws.Cell("P1").CurrentRegion.RangeAddress.ToString()); + + Assert.AreEqual("B1:D3", ws.Cell("D3").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("B1:D4", ws.Cell("D4").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("B1:E4", ws.Cell("E4").CurrentRegion.RangeAddress.ToString()); + + foreach (var c in ws.Range("B1:D3").Cells()) { - var ws = wb.AddWorksheet("Sheet1"); + Assert.AreEqual("B1:D3", c.CurrentRegion.RangeAddress.ToString()); + } - ws.Cell("B1").SetValue("x") - .CellBelow().SetValue("x") - .CellBelow().SetValue("x"); - - ws.Cell("C1").SetValue("x") - .CellBelow().SetValue("x") - .CellBelow().SetValue("x"); - - //Deliberately D2 - ws.Cell("D2").SetValue("x") - .CellBelow().SetValue("x"); - - ws.Cell("G1").SetValue("x") - .CellBelow() // skip a cell - .CellBelow().SetValue("x") - .CellBelow().SetValue("x"); - - // Deliberately H2 - ws.Cell("H2").SetValue("x") - .CellBelow().SetValue("x") - .CellBelow().SetValue("x"); - - // A diagonal - ws.Cell("E8").SetValue("x") - .CellBelow().CellRight().SetValue("x") - .CellBelow().CellRight().SetValue("x") - .CellBelow().CellRight().SetValue("x") - .CellBelow().CellRight().SetValue("x"); - - Assert.AreEqual("A10:A10", ws.Cell("A10").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("B5:B5", ws.Cell("B5").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("P1:P1", ws.Cell("P1").CurrentRegion.RangeAddress.ToString()); - - Assert.AreEqual("B1:D3", ws.Cell("D3").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("B1:D4", ws.Cell("D4").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("B1:E4", ws.Cell("E4").CurrentRegion.RangeAddress.ToString()); - - foreach (var c in ws.Range("B1:D3").Cells()) - { - Assert.AreEqual("B1:D3", c.CurrentRegion.RangeAddress.ToString()); - } - - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.AreEqual("A1:D3", c.CurrentRegion.RangeAddress.ToString()); - } - - Assert.AreEqual("A1:D4", ws.Cell("A4").CurrentRegion.RangeAddress.ToString()); - - foreach (var c in ws.Range("E1:E3").Cells()) - { - Assert.AreEqual("B1:E3", c.CurrentRegion.RangeAddress.ToString()); - } - - Assert.AreEqual("B1:E4", ws.Cell("E4").CurrentRegion.RangeAddress.ToString()); - - //// SECOND REGION - foreach (var c in ws.Range("F1:F4").Cells()) - { - Assert.AreEqual("F1:H4", c.CurrentRegion.RangeAddress.ToString()); - } - - Assert.AreEqual("F1:H5", ws.Cell("F5").CurrentRegion.RangeAddress.ToString()); - - //// DIAGONAL - Assert.AreEqual("E8:I12", ws.Cell("E8").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:I12", ws.Cell("F9").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:I12", ws.Cell("G10").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:I12", ws.Cell("H11").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:I12", ws.Cell("I12").CurrentRegion.RangeAddress.ToString()); - - Assert.AreEqual("E8:I12", ws.Cell("G9").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:I12", ws.Cell("F10").CurrentRegion.RangeAddress.ToString()); - - Assert.AreEqual("D7:I12", ws.Cell("D7").CurrentRegion.RangeAddress.ToString()); - Assert.AreEqual("E8:J13", ws.Cell("J13").CurrentRegion.RangeAddress.ToString()); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.AreEqual("A1:D3", c.CurrentRegion.RangeAddress.ToString()); } + + Assert.AreEqual("A1:D4", ws.Cell("A4").CurrentRegion.RangeAddress.ToString()); + + foreach (var c in ws.Range("E1:E3").Cells()) + { + Assert.AreEqual("B1:E3", c.CurrentRegion.RangeAddress.ToString()); + } + + Assert.AreEqual("B1:E4", ws.Cell("E4").CurrentRegion.RangeAddress.ToString()); + + //// SECOND REGION + foreach (var c in ws.Range("F1:F4").Cells()) + { + Assert.AreEqual("F1:H4", c.CurrentRegion.RangeAddress.ToString()); + } + + Assert.AreEqual("F1:H5", ws.Cell("F5").CurrentRegion.RangeAddress.ToString()); + + //// DIAGONAL + Assert.AreEqual("E8:I12", ws.Cell("E8").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:I12", ws.Cell("F9").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:I12", ws.Cell("G10").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:I12", ws.Cell("H11").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:I12", ws.Cell("I12").CurrentRegion.RangeAddress.ToString()); + + Assert.AreEqual("E8:I12", ws.Cell("G9").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:I12", ws.Cell("F10").CurrentRegion.RangeAddress.ToString()); + + Assert.AreEqual("D7:I12", ws.Cell("D7").CurrentRegion.RangeAddress.ToString()); + Assert.AreEqual("E8:J13", ws.Cell("J13").CurrentRegion.RangeAddress.ToString()); } // https://github.com/ClosedXML/ClosedXML/issues/630 [Test] public void ConsiderEmptyValueAsNumericInSumFormula() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").SetValue("Empty"); - ws.Cell("A2").SetValue("Numeric"); - ws.Cell("A3").SetValue("Copy of numeric"); + ws.Cell("A1").SetValue("Empty"); + ws.Cell("A2").SetValue("Numeric"); + ws.Cell("A3").SetValue("Copy of numeric"); - ws.Cell("B2").SetFormulaA1("=B1"); - ws.Cell("B3").SetFormulaA1("=B2"); + ws.Cell("B2").SetFormulaA1("=B1"); + ws.Cell("B3").SetFormulaA1("=B2"); - ws.Cell("C2").SetFormulaA1("=SUM(C1)"); - ws.Cell("C3").SetFormulaA1("=C2"); + ws.Cell("C2").SetFormulaA1("=SUM(C1)"); + ws.Cell("C3").SetFormulaA1("=C2"); - object b1 = ws.Cell("B1").Value; - object b2 = ws.Cell("B2").Value; - object b3 = ws.Cell("B3").Value; + var b1 = ws.Cell("B1").Value; + var b2 = ws.Cell("B2").Value; + var b3 = ws.Cell("B3").Value; - Assert.AreEqual("", b1); - Assert.AreEqual(0, b2); - Assert.AreEqual(0, b3); + Assert.AreEqual("", b1); + Assert.AreEqual(0, b2); + Assert.AreEqual(0, b3); - object c1 = ws.Cell("C1").Value; - object c2 = ws.Cell("C2").Value; - object c3 = ws.Cell("C3").Value; + var c1 = ws.Cell("C1").Value; + var c2 = ws.Cell("C2").Value; + var c3 = ws.Cell("C3").Value; - Assert.AreEqual("", c1); - Assert.AreEqual(0, c2); - Assert.AreEqual(0, c3); - } + Assert.AreEqual("", c1); + Assert.AreEqual(0, c2); + Assert.AreEqual(0, c3); } [Test] public void SetFormulaA1AffectsR1C1() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var cell = ws.Cell(1, 1); - cell.FormulaR1C1 = "R[1]C"; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var cell = ws.Cell(1, 1); + cell.FormulaR1C1 = "R[1]C"; - cell.FormulaA1 = "B2"; + cell.FormulaA1 = "B2"; - Assert.AreEqual("R[1]C[1]", cell.FormulaR1C1); - } + Assert.AreEqual("R[1]C[1]", cell.FormulaR1C1); } [Test] public void SetFormulaR1C1AffectsA1() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var cell = ws.Cell(1, 1); - cell.FormulaA1 = "A2"; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var cell = ws.Cell(1, 1); + cell.FormulaA1 = "A2"; - cell.FormulaR1C1 = "R[1]C[1]"; + cell.FormulaR1C1 = "R[1]C[1]"; - Assert.AreEqual("B2", cell.FormulaA1); - } + Assert.AreEqual("B2", cell.FormulaA1); } [Test] public void FormulaWithCircularReferenceFails() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var A1 = ws.Cell("A1"); + var A2 = ws.Cell("A2"); + A1.FormulaA1 = "A2 + 1"; + A2.FormulaA1 = "A1 + 1"; + + Assert.Throws(() => { - var ws = wb.AddWorksheet("Sheet1"); - var A1 = ws.Cell("A1"); - var A2 = ws.Cell("A2"); - A1.FormulaA1 = "A2 + 1"; - A2.FormulaA1 = "A1 + 1"; - - Assert.Throws(() => - { - var _ = A1.Value; - }); - Assert.Throws(() => - { - var _ = A2.Value; - }); - } + _ = A1.Value; + }); + Assert.Throws(() => + { + _ = A2.Value; + }); } [Test] public void InvalidFormulaShiftProducesREF() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell("A1").Value = 1; - ws.Cell("B1").Value = 2; - ws.Cell("B2").FormulaA1 = "=A1+B1"; + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell("A1").Value = 1; + ws.Cell("B1").Value = 2; + ws.Cell("B2").FormulaA1 = "=A1+B1"; - Assert.AreEqual(3, ws.Cell("B2").Value); + Assert.AreEqual(3, ws.Cell("B2").Value); - ws.Range("A2").Value = ws.Range("B2"); - var fA2 = ws.Cell("A2").FormulaA1; + ws.Range("A2").Value = ws.Range("B2"); + var fA2 = ws.Cell("A2").FormulaA1; - wb.SaveAs(ms); + wb.SaveAs(ms); - Assert.AreEqual("#REF!+A1", fA2); - } + Assert.AreEqual("#REF!+A1", fA2); + } - using (var wb2 = new XLWorkbook(ms)) - { - var fA2 = wb2.Worksheets.First().Cell("A2").FormulaA1; - Assert.AreEqual("#REF!+A1", fA2); - } + using (var wb2 = new XLWorkbook(ms)) + { + var fA2 = wb2.Worksheets.First().Cell("A2").FormulaA1; + Assert.AreEqual("#REF!+A1", fA2); } } [Test] public void FormulaWithCircularReferenceFails2() { - var cell = new XLWorkbook().Worksheets.Add("Sheet1").FirstCell(); + using var xLWorkbook = new XLWorkbook(); + var cell = xLWorkbook.Worksheets.Add("Sheet1").FirstCell(); cell.FormulaA1 = "A1"; Assert.Throws(() => { - var _ = cell.Value; + _ = cell.Value; }); } [Test] public void TryGetValueFormulaEvaluation() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var A1 = ws.Cell("A1"); - var A2 = ws.Cell("A2"); - var A3 = ws.Cell("A3"); - A1.FormulaA1 = "A2 + 1"; - A2.FormulaA1 = "A1 + 1"; - - Assert.IsFalse(A1.TryGetValue(out String _)); - Assert.IsFalse(A2.TryGetValue(out String _)); - Assert.IsTrue(A3.TryGetValue(out String _)); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var A1 = ws.Cell("A1"); + var A2 = ws.Cell("A2"); + var A3 = ws.Cell("A3"); + A1.FormulaA1 = "A2 + 1"; + A2.FormulaA1 = "A1 + 1"; + + Assert.IsFalse(A1.TryGetValue(out string _)); + Assert.IsFalse(A2.TryGetValue(out string _)); + Assert.IsTrue(A3.TryGetValue(out string _)); } [Test] @@ -1177,4 +1386,4 @@ public void ToStringInvalidFormat() Assert.Throws(() => c.ToString("dummy")); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Clearing/ClearingTests.cs b/ClosedXML.Tests/Excel/Clearing/ClearingTests.cs index 48a7ab572..320d007f4 100644 --- a/ClosedXML.Tests/Excel/Clearing/ClearingTests.cs +++ b/ClosedXML.Tests/Excel/Clearing/ClearingTests.cs @@ -4,18 +4,17 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Clearing { [TestFixture] public class ClearingTests { - private static XLColor backgroundColor = XLColor.LightBlue; - private static XLColor foregroundColor = XLColor.DarkBrown; + private static readonly XLColor backgroundColor = XLColor.LightBlue; + private static readonly XLColor foregroundColor = XLColor.DarkBrown; - private IXLWorkbook SetupWorkbook() + private IXLWorkbook SetupWorkbook(XLWorkbook wb) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + var ws = wb.Worksheets.Add("Sheet1"); var c = ws.FirstCell() .SetValue("Hello world!"); @@ -79,208 +78,206 @@ private IXLWorkbook SetupWorkbook() [Test] public void WorksheetClearAll() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyWb = new XLWorkbook(); + + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - ws.Clear(XLClearOptions.All); - - foreach (var c in ws.Range("A1:A10").Cells()) - { - Assert.IsTrue(c.IsEmpty()); - Assert.AreEqual(XLDataType.Text, c.DataType); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Font.FontColor, c.Style.Font.FontColor); - Assert.IsFalse(ws.ConditionalFormats.Any()); - Assert.IsFalse(c.HasComment); - Assert.AreEqual(String.Empty, c.GetDataValidation().Value); - } + ws.Clear(XLClearOptions.All); + + foreach (var c in ws.Range("A1:A10").Cells()) + { + Assert.IsTrue(c.IsEmpty()); + Assert.AreEqual(XLDataType.Text, c.DataType); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Font.FontColor, c.Style.Font.FontColor); + Assert.IsFalse(ws.ConditionalFormats.Any()); + Assert.IsFalse(c.HasComment); + Assert.AreEqual(string.Empty, c.GetDataValidation().Value); } } [Test] public void WorksheetClearContents() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyWb = new XLWorkbook(); - ws.Clear(XLClearOptions.Contents); + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsTrue(c.IsEmpty(XLCellsUsedOptions.Contents)); - Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); - Assert.IsTrue(ws.ConditionalFormats.Any()); - Assert.IsTrue(c.HasComment); - } + ws.Clear(XLClearOptions.Contents); - Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); - - Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); - Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); - Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsTrue(c.IsEmpty(XLCellsUsedOptions.Contents)); + Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); + Assert.IsTrue(ws.ConditionalFormats.Any()); + Assert.IsTrue(c.HasComment); } + + Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); + + Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); + Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); } [Test] public void WorksheetClearDataType() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyWb = new XLWorkbook(); - ws.Clear(XLClearOptions.DataType); + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsFalse(c.IsEmpty()); - Assert.AreEqual(XLDataType.Text, c.DataType); - Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); - Assert.IsTrue(ws.ConditionalFormats.Any()); - Assert.IsTrue(c.HasComment); - } + ws.Clear(XLClearOptions.DataType); - Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsFalse(c.IsEmpty()); + Assert.AreEqual(XLDataType.Text, c.DataType); + Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); + Assert.IsTrue(ws.ConditionalFormats.Any()); + Assert.IsTrue(c.HasComment); } + + Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); } [Test] public void WorksheetClearNormalFormats() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyWb = new XLWorkbook(); - ws.Clear(XLClearOptions.NormalFormats); + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsFalse(c.IsEmpty()); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Font.FontColor, c.Style.Font.FontColor); - Assert.IsTrue(ws.ConditionalFormats.Any()); - Assert.IsTrue(c.HasComment); - } + ws.Clear(XLClearOptions.NormalFormats); - Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); - Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); - Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); - - Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsFalse(c.IsEmpty()); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Font.FontColor, c.Style.Font.FontColor); + Assert.IsTrue(ws.ConditionalFormats.Any()); + Assert.IsTrue(c.HasComment); } + + Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); + Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + + Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); } [Test] public void WorksheetClearConditionalFormats() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); - - ws.Clear(XLClearOptions.ConditionalFormats); + using var emptyWb = new XLWorkbook(); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsFalse(c.IsEmpty()); - Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); - Assert.IsFalse(ws.ConditionalFormats.Any()); - Assert.IsTrue(c.HasComment); - } + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); - Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); - Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + ws.Clear(XLClearOptions.ConditionalFormats); - Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsFalse(c.IsEmpty()); + Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); + Assert.IsFalse(ws.ConditionalFormats.Any()); + Assert.IsTrue(c.HasComment); } + + Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); + Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + + Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); } [Test] public void WorksheetClearComments() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); - - ws.Clear(XLClearOptions.Comments); + using var emptyWb = new XLWorkbook(); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsFalse(c.IsEmpty()); - Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); - Assert.IsTrue(ws.ConditionalFormats.Any()); - Assert.IsFalse(c.HasComment); - } + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); - Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); - Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + ws.Clear(XLClearOptions.Comments); - Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsFalse(c.IsEmpty()); + Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); + Assert.IsTrue(ws.ConditionalFormats.Any()); + Assert.IsFalse(c.HasComment); } + + Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); + Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + + Assert.AreEqual("B1", ws.Cell("A1").GetDataValidation().Value); } [Test] public void WorksheetClearDataValidation() { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyWb = new XLWorkbook(); + using var wb = SetupWorkbook(emptyWb); + var ws = wb.Worksheets.First(); - ws.Clear(XLClearOptions.DataValidation); + ws.Clear(XLClearOptions.DataValidation); - foreach (var c in ws.Range("A1:A3").Cells()) - { - Assert.IsFalse(c.IsEmpty()); - Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); - Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); - Assert.IsTrue(ws.ConditionalFormats.Any()); - Assert.IsTrue(c.HasComment); - } + foreach (var c in ws.Range("A1:A3").Cells()) + { + Assert.IsFalse(c.IsEmpty()); + Assert.AreEqual(backgroundColor, c.Style.Fill.BackgroundColor); + Assert.AreEqual(foregroundColor, c.Style.Font.FontColor); + Assert.IsTrue(ws.ConditionalFormats.Any()); + Assert.IsTrue(c.HasComment); + } - Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); - Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); - Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A1").DataType); + Assert.AreEqual(XLDataType.Text, ws.Cell("A2").DataType); + Assert.AreEqual(XLDataType.DateTime, ws.Cell("A3").DataType); - Assert.AreEqual(string.Empty, ws.Cell("A1").GetDataValidation().Value); - } + Assert.AreEqual(string.Empty, ws.Cell("A1").GetDataValidation().Value); } [Test] public void DeleteClearedCellValue() { - using (var ms = new MemoryStream()) + using var emptyWb = new XLWorkbook(); + using var ms = new MemoryStream(); + using (var wb = SetupWorkbook(emptyWb)) { - using (var wb = SetupWorkbook()) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual("Hello world!", ws.Cell("A1").GetString()); - Assert.AreEqual(new DateTime(2018, 1, 15), ws.Cell("A3").GetDateTime()); - - wb.SaveAs(ms); - } - - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - ws.Clear(XLClearOptions.Contents); - Assert.AreEqual("", ws.Cell("A1").GetString()); - Assert.Throws(() => ws.Cell("A3").GetDateTime()); - - wb.Save(); - } - - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual("", ws.Cell("A1").GetString()); - Assert.Throws(() => ws.Cell("A3").GetDateTime()); - } + var ws = wb.Worksheets.First(); + Assert.AreEqual("Hello world!", ws.Cell("A1").GetString()); + Assert.AreEqual(new DateTime(2018, 1, 15), ws.Cell("A3").GetDateTime()); + + wb.SaveAs(ms); + } + + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + ws.Clear(XLClearOptions.Contents); + Assert.AreEqual("", ws.Cell("A1").GetString()); + Assert.Throws(() => ws.Cell("A3").GetDateTime()); + + wb.Save(); + } + + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.AreEqual("", ws.Cell("A1").GetString()); + Assert.Throws(() => ws.Cell("A3").GetDateTime()); } } @@ -291,19 +288,17 @@ public void DeleteClearedCellValue() [TestCase(XLClearOptions.MergedRanges, 2)] public void CanClearMergedRanges(XLClearOptions options, int expectedCount) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Test"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Test"); - ws.Range("A1:C3").Merge(); - ws.Range("A4:B6").Merge(); - ws.Range("D1:F3").Merge(); - ws.Range("E4:F6").Merge(); + ws.Range("A1:C3").Merge(); + ws.Range("A4:B6").Merge(); + ws.Range("D1:F3").Merge(); + ws.Range("E4:F6").Merge(); - ws.Range("C1:D6").Clear(options); + ws.Range("C1:D6").Clear(options); - Assert.AreEqual(expectedCount, ws.MergedRanges.Count); - } + Assert.AreEqual(expectedCount, ws.MergedRanges.Count); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Columns/ColumnTests.cs b/ClosedXML.Tests/Excel/Columns/ColumnTests.cs index 7246a81c7..0bc262e7a 100644 --- a/ClosedXML.Tests/Excel/Columns/ColumnTests.cs +++ b/ClosedXML.Tests/Excel/Columns/ColumnTests.cs @@ -1,9 +1,8 @@ using ClosedXML.Excel; using NUnit.Framework; -using System; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Columns { [TestFixture] public class ColumnTests @@ -11,15 +10,15 @@ public class ColumnTests [Test] public void ColumnUsed() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(2, 1).SetValue("Test"); ws.Cell(3, 1).SetValue("Test"); - IXLRangeColumn fromColumn = ws.Column(1).ColumnUsed(); + var fromColumn = ws.Column(1).ColumnUsed(); Assert.AreEqual("A2:A3", fromColumn.RangeAddress.ToStringRelative()); - IXLRangeColumn fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed(); + var fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed(); Assert.AreEqual("A2:A3", fromRange.RangeAddress.ToStringRelative()); } @@ -36,8 +35,8 @@ public void ColumnsUsedIsFast() [Test] public void CopyColumn() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Test").Style.Font.SetBold(); ws.FirstColumn().CopyTo(ws.Column(2)); @@ -47,18 +46,18 @@ public void CopyColumn() [Test] public void InsertingColumnsBefore1() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLColumn column1 = ws.Column(1); - IXLColumn column2 = ws.Column(2); - IXLColumn column3 = ws.Column(3); + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); - IXLColumn columnIns = ws.Column(1).InsertColumnsBefore(1).First(); + var columnIns = ws.Column(1).InsertColumnsBefore(1).First(); Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); @@ -100,18 +99,18 @@ public void InsertingColumnsBefore1() [Test] public void InsertingColumnsBefore2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLColumn column1 = ws.Column(1); - IXLColumn column2 = ws.Column(2); - IXLColumn column3 = ws.Column(3); + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); - IXLColumn columnIns = ws.Column(2).InsertColumnsBefore(1).First(); + var columnIns = ws.Column(2).InsertColumnsBefore(1).First(); Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); @@ -153,18 +152,18 @@ public void InsertingColumnsBefore2() [Test] public void InsertingColumnsBefore3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLColumn column1 = ws.Column(1); - IXLColumn column2 = ws.Column(2); - IXLColumn column3 = ws.Column(3); + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); - IXLColumn columnIns = ws.Column(3).InsertColumnsBefore(1).First(); + var columnIns = ws.Column(3).InsertColumnsBefore(1).First(); Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); @@ -206,15 +205,19 @@ public void InsertingColumnsBefore3() [Test] public void NoColumnsUsed() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - Int32 count = 0; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var count = 0; - foreach (IXLColumn row in ws.ColumnsUsed()) + foreach (var row in ws.ColumnsUsed()) + { count++; + } - foreach (IXLRangeColumn row in ws.Range("A1:C3").ColumnsUsed()) + foreach (var row in ws.Range("A1:C3").ColumnsUsed()) + { count++; + } Assert.AreEqual(0, count); } @@ -222,7 +225,7 @@ public void NoColumnsUsed() [Test] public void UngroupFromAll() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Columns(1, 2).Group(); ws.Columns(1, 2).Ungroup(true); } @@ -230,7 +233,7 @@ public void UngroupFromAll() [Test] public void LastColumnUsed() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "A1"; ws.Cell("B1").Value = "B1"; ws.Cell("A2").Value = "A2"; @@ -241,11 +244,11 @@ public void LastColumnUsed() [Test] public void NegativeColumnNumberIsInvalid() { - var ws = new XLWorkbook().AddWorksheet("Sheet1") as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1") as XLWorksheet; var column = new XLColumn(ws, -1); Assert.IsFalse(column.RangeAddress.IsValid); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Comments/CommentsTests.cs b/ClosedXML.Tests/Excel/Comments/CommentsTests.cs index 3c7ec825e..44e029db2 100644 --- a/ClosedXML.Tests/Excel/Comments/CommentsTests.cs +++ b/ClosedXML.Tests/Excel/Comments/CommentsTests.cs @@ -1,7 +1,6 @@ using ClosedXML.Excel; using DocumentFormat.OpenXml.Packaging; using NUnit.Framework; -using System; using System.IO; using System.Linq; @@ -12,25 +11,23 @@ public class CommentsTests [Test] public void CanGetColorFromIndex81() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentsWithIndexedColor81.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - var c = ws.FirstCellUsed(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentsWithIndexedColor81.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + var c = ws.FirstCellUsed(); - var xlColor = c.GetComment().Style.ColorsAndLines.LineColor; - Assert.AreEqual(XLColorType.Indexed, xlColor.ColorType); - Assert.AreEqual(81, xlColor.Indexed); + var xlColor = c.GetComment().Style.ColorsAndLines.LineColor; + Assert.AreEqual(XLColorType.Indexed, xlColor.ColorType); + Assert.AreEqual(81, xlColor.Indexed); - var color = xlColor.Color.ToHex(); - Assert.AreEqual("FF000000", color); - } + var color = xlColor.Color.ToHex(); + Assert.AreEqual("FF000000", color); } [Test] public void AddingCommentDoesNotAffectCollections() { - var ws = new XLWorkbook().AddWorksheet() as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet() as XLWorksheet; ws.Cell("A1").SetValue(10); ws.Cell("A4").SetValue(10); ws.Cell("A5").SetValue(10); @@ -52,143 +49,230 @@ public void AddingCommentDoesNotAffectCollections() [Test] public void CopyCommentStyle() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + var strExcelComment = "1) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "1) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "2) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "3) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "4) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "5) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "6) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "7) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "8) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + strExcelComment = strExcelComment + "9) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + XLConstants.NewLine; + + var cell = ws.Cell(2, 2).SetValue("Comment 1"); + + cell.GetComment() + .SetVisible(false) + .AddText(strExcelComment); + + cell.GetComment() + .Style + .Alignment + .SetAutomaticSize(); + + cell.GetComment() + .Style + .ColorsAndLines + .SetFillColor(XLColor.Red); + + ws.Row(1).InsertRowsAbove(1); + + static void validate(IXLCell c) { - var ws = wb.AddWorksheet("Sheet1"); + Assert.IsTrue(c.GetComment().Style.Alignment.AutomaticSize); + Assert.AreEqual(XLColor.Red, c.GetComment().Style.ColorsAndLines.FillColor); + } + + validate(ws.Cell("B3")); + + ws.Column(1).InsertColumnsBefore(2); - string strExcelComment = "1) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "1) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "2) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "3) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "4) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "5) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "6) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "7) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "8) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; - strExcelComment = strExcelComment + "9) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABC ABC ABC ABC ABC" + Environment.NewLine; + validate(ws.Cell("D3")); - var cell = ws.Cell(2, 2).SetValue("Comment 1"); + ws.Column(1).Delete(); - cell.GetComment() - .SetVisible(false) - .AddText(strExcelComment); + validate(ws.Cell("C3")); + + ws.Row(1).Delete(); + + validate(ws.Cell("C2")); + } + + [Test] + public void EnsureUnaffectedCommentAndVmlPartIdsAndUris() + { + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentAndButton.xlsx")); + using var ms = new MemoryStream(); + string commentPartId; + string commentPartUri; - cell.GetComment() - .Style - .Alignment - .SetAutomaticSize(); + string vmlPartId; + string vmlPartUri; - cell.GetComment() - .Style - .ColorsAndLines - .SetFillColor(XLColor.Red); + using (var ssd = SpreadsheetDocument.Open(stream, isEditable: false)) + { + var wbp = ssd.GetPartsOfType().Single(); + var wsp = wbp.GetPartsOfType().Last(); - ws.Row(1).InsertRowsAbove(1); + var wscp = wsp.GetPartsOfType().Single(); + commentPartId = wsp.GetIdOfPart(wscp); + commentPartUri = wscp.Uri.ToString(); - Action validate = c => - { - Assert.IsTrue(c.GetComment().Style.Alignment.AutomaticSize); - Assert.AreEqual(XLColor.Red, c.GetComment().Style.ColorsAndLines.FillColor); - }; + var vmlp = wsp.GetPartsOfType().Single(); + vmlPartId = wsp.GetIdOfPart(vmlp); + vmlPartUri = vmlp.Uri.ToString(); + } - validate(ws.Cell("B3")); + stream.Position = 0; + stream.CopyTo(ms); + ms.Position = 0; - ws.Column(1).InsertColumnsBefore(2); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.IsTrue(ws.FirstCell().HasComment); - validate(ws.Cell("D3")); + wb.SaveAs(ms); + } - ws.Column(1).Delete(); + ms.Position = 0; - validate(ws.Cell("C3")); + using (var ssd = SpreadsheetDocument.Open(ms, isEditable: false)) + { + var wbp = ssd.GetPartsOfType().Single(); + var wsp = wbp.GetPartsOfType().Last(); - ws.Row(1).Delete(); + var wscp = wsp.GetPartsOfType().Single(); + Assert.AreEqual(commentPartUri, wscp.Uri.ToString()); + Assert.AreEqual(commentPartId, wsp.GetIdOfPart(wscp)); - validate(ws.Cell("C2")); + var vmlp = wsp.GetPartsOfType().Single(); + Assert.AreEqual(vmlPartUri, vmlp.Uri.ToString()); + Assert.AreEqual(vmlPartId, wsp.GetIdOfPart(vmlp)); } } [Test] - public void EnsureUnaffectedCommentAndVmlPartIdsAndUris() + public void SavingDoesNotCauseTwoRootElements() // See #1157 { + using var ms = new MemoryStream(); using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentAndButton.xlsx"))) - using (var ms = new MemoryStream()) + using (var wb = new XLWorkbook(stream)) { - string commentPartId; - string commentPartUri; + wb.SaveAs(ms); + } - string vmlPartId; - string vmlPartUri; + Assert.DoesNotThrow(() => new XLWorkbook(ms)); + } - using (var ssd = SpreadsheetDocument.Open(stream, isEditable: false)) - { - var wbp = ssd.GetPartsOfType().Single(); - var wsp = wbp.GetPartsOfType().Last(); + [Test] + public void CanLoadCommentVisibility() + { + using var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Drawings\Comments\inputfile.xlsx")); + using var workbook = new XLWorkbook(inputStream); + var ws = workbook.Worksheets.First(); - var wscp = wsp.GetPartsOfType().Single(); - commentPartId = wsp.GetIdOfPart(wscp); - commentPartUri = wscp.Uri.ToString(); + Assert.True(ws.Cell("A1").GetComment().Visible); + Assert.False(ws.Cell("A4").GetComment().Visible); + } - var vmlp = wsp.GetPartsOfType().Single(); - vmlPartId = wsp.GetIdOfPart(vmlp); - vmlPartUri = vmlp.Uri.ToString(); - } + [Test] + public void CanRemoveCommentsWithoutAddingOthers() // see #1575 + { + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) + { + var sheet = wb.AddWorksheet("sheet1"); - stream.Position = 0; - stream.CopyTo(ms); - ms.Position = 0; + //guard + var cellsWithComments1 = wb.Worksheets.SelectMany(_ => _.CellsUsed(XLCellsUsedOptions.Comments)).ToArray(); + Assert.That(cellsWithComments1, Is.Empty); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.IsTrue(ws.FirstCell().HasComment); + var a1 = sheet.Cell("A1"); + var b5 = sheet.Cell("B5"); - wb.SaveAs(ms); - } + a1.SetValue("test a1"); + b5.SetValue("test b5"); - ms.Position = 0; + var cellsWithComments2 = wb.Worksheets.SelectMany(_ => _.CellsUsed(XLCellsUsedOptions.Comments)).ToArray(); + Assert.That(cellsWithComments2, Is.Empty); - using (var ssd = SpreadsheetDocument.Open(ms, isEditable: false)) - { - var wbp = ssd.GetPartsOfType().Single(); - var wsp = wbp.GetPartsOfType().Last(); + a1.GetComment().AddText("no comment"); - var wscp = wsp.GetPartsOfType().Single(); - Assert.AreEqual(commentPartUri, wscp.Uri.ToString()); - Assert.AreEqual(commentPartId, wsp.GetIdOfPart(wscp)); + //guard + var cellsWithComments3 = wb.Worksheets.SelectMany(_ => _.CellsUsed(XLCellsUsedOptions.Comments)).ToArray(); + Assert.That(cellsWithComments3.Length, Is.EqualTo(1)); - var vmlp = wsp.GetPartsOfType().Single(); - Assert.AreEqual(vmlPartUri, vmlp.Uri.ToString()); - Assert.AreEqual(vmlPartId, wsp.GetIdOfPart(vmlp)); - } + wb.SaveAs(ms, true); + } + + ms.Position = 0; + + using (var wb = new XLWorkbook(ms)) + { + var cellsWithComments = wb.Worksheets.SelectMany(_ => _.CellsUsed(XLCellsUsedOptions.Comments)).ToArray(); + + Assert.That(cellsWithComments.Length, Is.EqualTo(1)); + + // act + cellsWithComments.ForEach(_ => _.Clear(XLClearOptions.Comments)); + + wb.Save(); + } + + ms.Position = 0; + + using (var wb = new XLWorkbook(ms)) + { + // assert + var cellsWithComments = wb.Worksheets.SelectMany(_ => _.Cells(true, XLCellsUsedOptions.Comments)).ToArray(); + + Assert.That(cellsWithComments, Is.Empty); } } [Test] - public void SavingDoesNotCauseTwoRootElements() // See #1157 + public void CanDeleteFormattedNote() { - using (var ms = new MemoryStream()) - { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentAndButton.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - wb.SaveAs(ms); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentFormatted.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); - Assert.DoesNotThrow(() => new XLWorkbook(ms)); - } + var cellsWithComments = ws.CellsUsed(XLCellsUsedOptions.Comments).ToArray(); + + Assert.That(cellsWithComments.Length, Is.EqualTo(2)); + + Assert.That(cellsWithComments[0].GetComment().Text, Is.EqualTo(@"normal Note")); + Assert.That(cellsWithComments[1].GetComment().Text, Is.EqualTo("Author:\r\nboldAndUnderlinenormal bold italic normal")); + + cellsWithComments[0].Clear(XLClearOptions.Comments); + cellsWithComments[1].Clear(XLClearOptions.Comments); + + cellsWithComments = ws.CellsUsed(XLCellsUsedOptions.Comments).ToArray(); + // TODO: this breaks when it should not + Assert.That(cellsWithComments.Length, Is.EqualTo(0)); } [Test] - public void CanLoadCommentVisibility() + public void CanReadThreadedCommentNote() { - using (var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Drawings\Comments\inputfile.xlsx"))) - using (var workbook = new XLWorkbook(inputStream)) - { - var ws = workbook.Worksheets.First(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\ThreadedComment.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + var c = ws.FirstCellUsed(); - Assert.True(ws.Cell("A1").GetComment().Visible); - Assert.False(ws.Cell("A4").GetComment().Visible); - } + Assert.AreEqual(c.GetComment().Text, @"[Threaded comment] + +Your version of Excel allows you to read this threaded comment; however, any edits to it will get removed if the file is opened in a newer version of Excel. Learn more: https://go.microsoft.com/fwlink/?linkid=870924 + +Comment: + This is a threaded comment. +Reply: + This is a reply."); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatCopyTests.cs b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatCopyTests.cs index 21c8af8e4..256aeaa54 100644 --- a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatCopyTests.cs +++ b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatCopyTests.cs @@ -11,13 +11,13 @@ public class ConditionalFormatCopyTests [Test] public void StylesAreCreatedDuringCopy() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet"); var format = ws.Range("A1:A1").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill .SetBackgroundColor(XLColor.Blue); - var wb2 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); var ws2 = wb2.Worksheets.Add("Sheet2"); ws2.FirstCell().CopyFrom(ws.FirstCell()); Assert.That(ws2.ConditionalFormats.First().Style.Fill.BackgroundColor, Is.EqualTo(XLColor.Blue)); //Added blue style @@ -26,7 +26,7 @@ public void StylesAreCreatedDuringCopy() [Test] public void CopyConditionalFormatSingleWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet"); var format = ws.Range("A1:A1").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill @@ -43,7 +43,7 @@ public void CopyConditionalFormatSingleWorksheet() [Test] public void CopyConditionalFormatSameRange() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet"); var format = ws.Range("A1:C3").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill @@ -59,7 +59,7 @@ public void CopyConditionalFormatSameRange() [Test] public void CopyConditionalFormatsDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var format = ws1.Range("A1:A1").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill @@ -82,13 +82,13 @@ public void CopyConditionalFormatsDifferentWorksheets() [Test] public void FullCopyConditionalFormatSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var format = (XLConditionalFormat)ws1.Range("A1:A1").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill .SetBackgroundColor(XLColor.Blue); - TestDelegate action = () => format.CopyTo(ws1); + void action() => format.CopyTo(ws1); Assert.Throws(typeof(InvalidOperationException), action); } @@ -96,7 +96,7 @@ public void FullCopyConditionalFormatSameWorksheet() [Test] public void FullCopyConditionalFormatDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var format = (XLConditionalFormat)ws1.Range("A1:C3").AddConditionalFormat(); format.WhenEquals("=" + format.Ranges.First().FirstCell().CellRight(4).Address.ToStringRelative()).Fill @@ -113,4 +113,4 @@ public void FullCopyConditionalFormatDifferentWorksheets() Assert.AreEqual("Sheet2!A1:C3", ws2.ConditionalFormats.First().Ranges.First().RangeAddress.ToString(XLReferenceStyle.A1, true)); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatShiftTests.cs b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatShiftTests.cs index 550aa1ed0..09edf6a1d 100644 --- a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatShiftTests.cs +++ b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatShiftTests.cs @@ -10,118 +10,108 @@ public class ConditionalFormatShiftTests [Test] public void CFShiftedOnColumnInsert() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("CFShift"); - ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); - ws.Range("A2:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); - ws.Range("A3:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); - ws.Range("B4:B6").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); - ws.Range("C7:D7").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); - ws.Cells("A1:D7").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("CFShift"); + ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); + ws.Range("A2:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); + ws.Range("A3:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); + ws.Range("B4:B6").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); + ws.Range("C7:D7").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); + ws.Cells("A1:D7").Value = 1; - ws.Column(2).InsertColumnsAfter(2); - var cf = ws.ConditionalFormats.ToArray(); + ws.Column(2).InsertColumnsAfter(2); + var cf = ws.ConditionalFormats.ToArray(); - Assert.AreEqual(5, cf.Length); - Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); - Assert.AreEqual("A2:D2", cf[1].Range.RangeAddress.ToString()); - Assert.AreEqual("A3:E3", cf[2].Range.RangeAddress.ToString()); - Assert.AreEqual("B4:D6", cf[3].Range.RangeAddress.ToString()); - Assert.AreEqual("E7:F7", cf[4].Range.RangeAddress.ToString()); - } + Assert.AreEqual(5, cf.Length); + Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); + Assert.AreEqual("A2:D2", cf[1].Range.RangeAddress.ToString()); + Assert.AreEqual("A3:E3", cf[2].Range.RangeAddress.ToString()); + Assert.AreEqual("B4:D6", cf[3].Range.RangeAddress.ToString()); + Assert.AreEqual("E7:F7", cf[4].Range.RangeAddress.ToString()); } [Test] public void CFShiftedOnRowInsert() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("CFShift"); - ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); - ws.Range("B1:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); - ws.Range("C1:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); - ws.Range("D2:F2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); - ws.Range("G4:G5").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); - ws.Cells("A1:G5").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("CFShift"); + ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); + ws.Range("B1:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); + ws.Range("C1:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); + ws.Range("D2:F2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); + ws.Range("G4:G5").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); + ws.Cells("A1:G5").Value = 1; - ws.Row(2).InsertRowsBelow(2); - var cf = ws.ConditionalFormats.ToArray(); + ws.Row(2).InsertRowsBelow(2); + var cf = ws.ConditionalFormats.ToArray(); - Assert.AreEqual(5, cf.Length); - Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); - Assert.AreEqual("B1:B4", cf[1].Range.RangeAddress.ToString()); - Assert.AreEqual("C1:C5", cf[2].Range.RangeAddress.ToString()); - Assert.AreEqual("D2:F4", cf[3].Range.RangeAddress.ToString()); - Assert.AreEqual("G6:G7", cf[4].Range.RangeAddress.ToString()); - } + Assert.AreEqual(5, cf.Length); + Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); + Assert.AreEqual("B1:B4", cf[1].Range.RangeAddress.ToString()); + Assert.AreEqual("C1:C5", cf[2].Range.RangeAddress.ToString()); + Assert.AreEqual("D2:F4", cf[3].Range.RangeAddress.ToString()); + Assert.AreEqual("G6:G7", cf[4].Range.RangeAddress.ToString()); } [Test] public void CFShiftedOnColumnDelete() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("CFShift"); - ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); - ws.Range("A2:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); - ws.Range("A3:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); - ws.Range("B4:B6").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); - ws.Range("C7:D7").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); - ws.Cells("A1:D7").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("CFShift"); + ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); + ws.Range("A2:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); + ws.Range("A3:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); + ws.Range("B4:B6").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); + ws.Range("C7:D7").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); + ws.Cells("A1:D7").Value = 1; - ws.Column(2).Delete(); - var cf = ws.ConditionalFormats.ToArray(); + ws.Column(2).Delete(); + var cf = ws.ConditionalFormats.ToArray(); - Assert.AreEqual(4, cf.Length); - Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); - Assert.AreEqual("A2:A2", cf[1].Range.RangeAddress.ToString()); - Assert.AreEqual("A3:B3", cf[2].Range.RangeAddress.ToString()); - Assert.AreEqual("B7:C7", cf[3].Range.RangeAddress.ToString()); - } + Assert.AreEqual(4, cf.Length); + Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); + Assert.AreEqual("A2:A2", cf[1].Range.RangeAddress.ToString()); + Assert.AreEqual("A3:B3", cf[2].Range.RangeAddress.ToString()); + Assert.AreEqual("B7:C7", cf[3].Range.RangeAddress.ToString()); } [Test] public void CFShiftedOnRowDelete() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("CFShift"); - ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); - ws.Range("B1:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); - ws.Range("C1:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); - ws.Range("D2:F2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); - ws.Range("G4:G5").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); - ws.Cells("A1:G5").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("CFShift"); + ws.Range("A1:A1").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AirForceBlue); + ws.Range("B1:B2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.AliceBlue); + ws.Range("C1:C3").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Alizarin); + ws.Range("D2:F2").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Almond); + ws.Range("G4:G5").AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Amaranth); + ws.Cells("A1:G5").Value = 1; - ws.Row(2).Delete(); - var cf = ws.ConditionalFormats.ToArray(); + ws.Row(2).Delete(); + var cf = ws.ConditionalFormats.ToArray(); - Assert.AreEqual(4, cf.Length); - Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); - Assert.AreEqual("B1:B1", cf[1].Range.RangeAddress.ToString()); - Assert.AreEqual("C1:C2", cf[2].Range.RangeAddress.ToString()); - Assert.AreEqual("G3:G4", cf[3].Range.RangeAddress.ToString()); - } + Assert.AreEqual(4, cf.Length); + Assert.AreEqual("A1:A1", cf[0].Range.RangeAddress.ToString()); + Assert.AreEqual("B1:B1", cf[1].Range.RangeAddress.ToString()); + Assert.AreEqual("C1:C2", cf[2].Range.RangeAddress.ToString()); + Assert.AreEqual("G3:G4", cf[3].Range.RangeAddress.ToString()); } [Test] public void CFShiftedTruncateRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("CFShift"); - ws.AsRange().AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Red); - var cf = ws.ConditionalFormats.Single(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("CFShift"); + ws.AsRange().AddConditionalFormat().WhenGreaterThan(0).Fill.SetBackgroundColor(XLColor.Red); + var cf = ws.ConditionalFormats.Single(); - ws.Row(2).InsertRowsAbove(1); - Assert.IsTrue(cf.Range.RangeAddress.IsValid); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", cf.Range.RangeAddress.ToString()); + ws.Row(2).InsertRowsAbove(1); + Assert.IsTrue(cf.Range.RangeAddress.IsValid); + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", cf.Range.RangeAddress.ToString()); - ws.Column(2).InsertColumnsAfter(1); - Assert.IsTrue(cf.Range.RangeAddress.IsValid); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", cf.Range.RangeAddress.ToString()); - } + ws.Column(2).InsertColumnsAfter(1); + Assert.IsTrue(cf.Range.RangeAddress.IsValid); + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", cf.Range.RangeAddress.ToString()); } } } diff --git a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatTests.cs b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatTests.cs index e18b5d8d0..0290f464c 100644 --- a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatTests.cs +++ b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatTests.cs @@ -13,16 +13,14 @@ public class ConditionalFormatTests [Test] public void MaintainConditionalFormattingOrder() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\ConditionalFormattingOrder\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\ConditionalFormattingOrder\inputfile.xlsx")); + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - wb.SaveAs(ms); - return wb; - }, @"Other\StyleReferenceFiles\ConditionalFormattingOrder\ConditionalFormattingOrder.xlsx"); - } + var wb = new XLWorkbook(stream); + wb.SaveAs(ms); + return wb; + }, @"Other\StyleReferenceFiles\ConditionalFormattingOrder\ConditionalFormattingOrder.xlsx"); } [TestCase(true, 7)] @@ -34,7 +32,7 @@ public void SaveOptionAffectsConsolidationConditionalFormatRanges(bool consolida ConsolidateConditionalFormatRanges = consolidateConditionalFormatRanges }; - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet"); ws.Range("D2:D3").AddConditionalFormat().DataBar(XLColor.Red).LowestValue().HighestValue(); @@ -45,12 +43,10 @@ public void SaveOptionAffectsConsolidationConditionalFormatRanges(bool consolida ws.Range("H2:H7").AddConditionalFormat().WhenIsUnique().Fill.SetBackgroundColor(XLColor.Blue); ws.Range("I2:I6").AddConditionalFormat().WhenContains("test"); ws.Range("J2:J6").AddConditionalFormat().WhenContains("test"); - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, options); - var wb_saved = new XLWorkbook(ms); - Assert.AreEqual(expectedCount, wb_saved.Worksheet("Sheet").ConditionalFormats.Count()); - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, options); + using var wb_saved = new XLWorkbook(ms); + Assert.AreEqual(expectedCount, wb_saved.Worksheet("Sheet").ConditionalFormats.Count()); } [TestCase(true, 1)] @@ -62,17 +58,15 @@ public void SaveOptionAffectsConsolidationDataValidationRanges(bool consolidateD ConsolidateDataValidationRanges = consolidateDataValidationRanges }; - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet"); ws.Range("C2:C5").CreateDataValidation().Decimal.Between(1, 5); ws.Range("D2:D5").CreateDataValidation().Decimal.Between(1, 5); - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, options); - var wb_saved = new XLWorkbook(ms); - Assert.AreEqual(expectedCount, wb_saved.Worksheet("Sheet").DataValidations.Count()); - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, options); + using var wb_saved = new XLWorkbook(ms); + Assert.AreEqual(expectedCount, wb_saved.Worksheet("Sheet").DataValidations.Count()); } [TestCase("en-US")] @@ -80,39 +74,37 @@ public void SaveOptionAffectsConsolidationDataValidationRanges(bool consolidateD [TestCase("ru-RU")] public void SaveConditionalFormat_CultureIndependent(string culture) { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + var expectedValue = 1.5; + Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture); + using (var wb = new XLWorkbook()) { - var expectedValue = 1.5; - Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture); - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var i = 1; - ws.Cell(i++, 1).AddConditionalFormat().WhenEquals(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenNotEquals(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenGreaterThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenLessThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenEqualOrGreaterThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenEqualOrLessThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenBetween(expectedValue, expectedValue).Fill.SetBackgroundColor(XLColor.Red); - ws.Cell(i++, 1).AddConditionalFormat().WhenNotBetween(expectedValue, expectedValue).Fill.SetBackgroundColor(XLColor.Red); + var ws = wb.AddWorksheet(); + var i = 1; + ws.Cell(i++, 1).AddConditionalFormat().WhenEquals(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenNotEquals(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenGreaterThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenLessThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenEqualOrGreaterThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenEqualOrLessThan(expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i++, 1).AddConditionalFormat().WhenBetween(expectedValue, expectedValue).Fill.SetBackgroundColor(XLColor.Red); + ws.Cell(i, 1).AddConditionalFormat().WhenNotBetween(expectedValue, expectedValue).Fill.SetBackgroundColor(XLColor.Red); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); - var conditionalFormatValues = ws.ConditionalFormats - .SelectMany(cf => cf.Values.Values) - .Select(v => v.Value) - .Distinct(); + var conditionalFormatValues = ws.ConditionalFormats + .SelectMany(cf => cf.Values.Values) + .Select(v => v.Value) + .Distinct(); - Assert.AreEqual(1, conditionalFormatValues.Count()); - Assert.AreEqual("1.5", conditionalFormatValues.Single()); - } + Assert.AreEqual(1, conditionalFormatValues.Count()); + Assert.AreEqual("1.5", conditionalFormatValues.Single()); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatsConsolidateTests.cs b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatsConsolidateTests.cs index fd07394fa..4097ea56a 100644 --- a/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatsConsolidateTests.cs +++ b/ClosedXML.Tests/Excel/ConditionalFormats/ConditionalFormatsConsolidateTests.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel; +using ClosedXML.Excel.Ranges; using NUnit.Framework; using System.Linq; @@ -10,8 +11,8 @@ public class ConditionalFormatsConsolidateTests [Test] public void ConsecutivelyRowsConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("B2:C2").AddConditionalFormat()); SetFormat1(ws.Range("B4:C4").AddConditionalFormat()); @@ -28,8 +29,8 @@ public void ConsecutivelyRowsConsolidateTest() [Test] public void ConsecutivelyColumnsConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("D2:D3").AddConditionalFormat()); SetFormat1(ws.Range("B2:B3").AddConditionalFormat()); @@ -46,8 +47,8 @@ public void ConsecutivelyColumnsConsolidateTest() [Test] public void Contains1ConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("B11:D12").AddConditionalFormat()); SetFormat1(ws.Range("C12:D12").AddConditionalFormat()); @@ -63,8 +64,8 @@ public void Contains1ConsolidateTest() [Test] public void Contains2ConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("B14:C14").AddConditionalFormat()); SetFormat1(ws.Range("B14:B14").AddConditionalFormat()); @@ -80,8 +81,8 @@ public void Contains2ConsolidateTest() [Test] public void SuperimposedConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("B16:D18").AddConditionalFormat()); SetFormat1(ws.Range("B18:D19").AddConditionalFormat()); @@ -97,8 +98,8 @@ public void SuperimposedConsolidateTest() [Test] public void DifferentFormatNoConsolidateTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("B11:D12").AddConditionalFormat()); SetFormat2(ws.Range("C12:D12").AddConditionalFormat()); @@ -111,8 +112,8 @@ public void DifferentFormatNoConsolidateTest() [Test] public void ConsolidatePreservesPriorities() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("A1:A5").AddConditionalFormat()); SetFormat2(ws.Range("A1:A5").AddConditionalFormat()); @@ -129,8 +130,8 @@ public void ConsolidatePreservesPriorities() [Test] public void ConsolidatePreservesPriorities2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); SetFormat1(ws.Range("A1:A1").AddConditionalFormat()); SetFormat2(ws.Range("A2:A3").AddConditionalFormat()); @@ -151,8 +152,8 @@ public void ConsolidatePreservesPriorities2() [Test] public void ConsolidateShiftsFormulaRelativelyToTopMostCell() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); var ranges = ws.Ranges("B3:B8,C3:C4,A3:A4,C5:C8,A5:A8").Cast(); var cf = new XLConditionalFormat(ranges); @@ -172,22 +173,20 @@ public void ConsolidateShiftsFormulaRelativelyToTopMostCell() [Test] public void ColorScaleComparing() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet"); - - var ranges = ws.Ranges("B3:B8,C3:C4,A3:A4,C5:C8,A5:A8").Cast(); - var cf1 = new XLConditionalFormat(ranges); - cf1.ColorScale() - .LowestValue(XLColor.Red) - .HighestValue(XLColor.Green); - - var cf2 = new XLConditionalFormat(ranges); - cf2.ColorScale() - .LowestValue(XLColor.Red) - .HighestValue(XLColor.Green); - Assert.True(XLConditionalFormat.NoRangeComparer.Equals(cf1, cf2)); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); + + var ranges = ws.Ranges("B3:B8,C3:C4,A3:A4,C5:C8,A5:A8").Cast(); + var cf1 = new XLConditionalFormat(ranges); + cf1.ColorScale() + .LowestValue(XLColor.Red) + .HighestValue(XLColor.Green); + + var cf2 = new XLConditionalFormat(ranges); + cf2.ColorScale() + .LowestValue(XLColor.Red) + .HighestValue(XLColor.Green); + Assert.True(XLConditionalFormat.NoRangeComparer.Equals(cf1, cf2)); } private static void SetFormat1(IXLConditionalFormat format) @@ -200,4 +199,4 @@ private static void SetFormat2(IXLConditionalFormat format) format.WhenEquals(5).Fill.SetBackgroundColor(XLColor.AliceBlue); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Coordinates/XLAddressTests.cs b/ClosedXML.Tests/Excel/Coordinates/XLAddressTests.cs index 471c6a08e..b35e7dd4f 100644 --- a/ClosedXML.Tests/Excel/Coordinates/XLAddressTests.cs +++ b/ClosedXML.Tests/Excel/Coordinates/XLAddressTests.cs @@ -1,7 +1,7 @@ using ClosedXML.Excel; using NUnit.Framework; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Coordinates { [TestFixture] public class XLAddressTests @@ -9,8 +9,8 @@ public class XLAddressTests [Test] public void ToStringTest() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLAddress address = ws.Cell(1, 1).Address; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var address = ws.Cell(1, 1).Address; Assert.AreEqual("A1", address.ToString()); Assert.AreEqual("A1", address.ToString(XLReferenceStyle.A1)); @@ -33,8 +33,8 @@ public void ToStringTest() [Test] public void ToStringTestWithSpace() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); - IXLAddress address = ws.Cell(1, 1).Address; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); + var address = ws.Cell(1, 1).Address; Assert.AreEqual("A1", address.ToString()); Assert.AreEqual("A1", address.ToString(XLReferenceStyle.A1)); @@ -163,7 +163,7 @@ public void InvalidAddressOnDeletedWorksheetToStringRelativeTest() private IXLAddress ProduceInvalidAddress() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); var range = ws.Range("A1:B2"); ws.Rows(1, 5).Delete(); @@ -172,7 +172,7 @@ private IXLAddress ProduceInvalidAddress() private IXLAddress ProduceAddressOnDeletedWorksheet() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); var address = ws.Cell("A1").Address; ws.Delete(); @@ -188,4 +188,4 @@ private IXLAddress ProduceInvalidAddressOnDeletedWorksheet() #endregion Private Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/DataValidations/DataValidationShiftTests.cs b/ClosedXML.Tests/Excel/DataValidations/DataValidationShiftTests.cs index 9be16e1c1..bc6d6428a 100644 --- a/ClosedXML.Tests/Excel/DataValidations/DataValidationShiftTests.cs +++ b/ClosedXML.Tests/Excel/DataValidations/DataValidationShiftTests.cs @@ -10,118 +10,108 @@ public class DataValidationShiftTests [Test] public void DataValidationShiftedOnColumnInsert() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("DataValidationShift"); - ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("A2:B2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("A3:C3").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("B4:B6").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("C7:D7").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Cells("A1:D7").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("DataValidationShift"); + ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("A2:B2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("A3:C3").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("B4:B6").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("C7:D7").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Cells("A1:D7").Value = 1; - ws.Column(2).InsertColumnsAfter(2); - var dv = ws.DataValidations.ToArray(); + ws.Column(2).InsertColumnsAfter(2); + var dv = ws.DataValidations.ToArray(); - Assert.AreEqual(5, dv.Length); - Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("A2:D2", dv[1].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("A3:E3", dv[2].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("B4:D6", dv[3].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("E7:F7", dv[4].Ranges.Single().RangeAddress.ToString()); - } + Assert.AreEqual(5, dv.Length); + Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("A2:D2", dv[1].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("A3:E3", dv[2].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("B4:D6", dv[3].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("E7:F7", dv[4].Ranges.Single().RangeAddress.ToString()); } [Test] public void DataValidationShiftedOnRowInsert() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("DataValidationShift"); - ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("B1:B2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("C1:C3").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("D2:F2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("G4:G5").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Cells("A1:G5").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("DataValidationShift"); + ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("B1:B2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("C1:C3").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("D2:F2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("G4:G5").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Cells("A1:G5").Value = 1; - ws.Row(2).InsertRowsBelow(2); - var dv = ws.DataValidations.ToArray(); + ws.Row(2).InsertRowsBelow(2); + var dv = ws.DataValidations.ToArray(); - Assert.AreEqual(5, dv.Length); - Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("B1:B4", dv[1].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("C1:C5", dv[2].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("D2:F4", dv[3].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("G6:G7", dv[4].Ranges.Single().RangeAddress.ToString()); - } + Assert.AreEqual(5, dv.Length); + Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("B1:B4", dv[1].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("C1:C5", dv[2].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("D2:F4", dv[3].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("G6:G7", dv[4].Ranges.Single().RangeAddress.ToString()); } [Test] public void DataValidationShiftedOnColumnDelete() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("DataValidationShift"); - ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("A2:B2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("A3:C3").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("B4:B6").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("C7:D7").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Cells("A1:D7").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("DataValidationShift"); + ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("A2:B2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("A3:C3").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("B4:B6").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("C7:D7").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Cells("A1:D7").Value = 1; - ws.Column(2).Delete(); - var dv = ws.DataValidations.ToArray(); + ws.Column(2).Delete(); + var dv = ws.DataValidations.ToArray(); - Assert.AreEqual(4, dv.Length); - Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("A2:A2", dv[1].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("A3:B3", dv[2].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("B7:C7", dv[3].Ranges.Single().RangeAddress.ToString()); - } + Assert.AreEqual(4, dv.Length); + Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("A2:A2", dv[1].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("A3:B3", dv[2].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("B7:C7", dv[3].Ranges.Single().RangeAddress.ToString()); } [Test] public void DataValidationShiftedOnRowDelete() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("DataValidationShift"); - ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("B1:B2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("C1:C3").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("D2:F2").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Range("G4:G5").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Cells("A1:G5").Value = 1; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("DataValidationShift"); + ws.Range("A1:A1").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("B1:B2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("C1:C3").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("D2:F2").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Range("G4:G5").CreateDataValidation().WholeNumber.Between(0, 1); + ws.Cells("A1:G5").Value = 1; - ws.Row(2).Delete(); - var dv = ws.DataValidations.ToArray(); + ws.Row(2).Delete(); + var dv = ws.DataValidations.ToArray(); - Assert.AreEqual(4, dv.Length); - Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("B1:B1", dv[1].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("C1:C2", dv[2].Ranges.Single().RangeAddress.ToString()); - Assert.AreEqual("G3:G4", dv[3].Ranges.Single().RangeAddress.ToString()); - } + Assert.AreEqual(4, dv.Length); + Assert.AreEqual("A1:A1", dv[0].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("B1:B1", dv[1].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("C1:C2", dv[2].Ranges.Single().RangeAddress.ToString()); + Assert.AreEqual("G3:G4", dv[3].Ranges.Single().RangeAddress.ToString()); } [Test] public void DataValidationShiftedTruncateRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("DataValidationShift"); - ws.AsRange().CreateDataValidation().WholeNumber.Between(0, 1); - var dv = ws.DataValidations.Single(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("DataValidationShift"); + ws.AsRange().CreateDataValidation().WholeNumber.Between(0, 1); + var dv = ws.DataValidations.Single(); - ws.Row(2).InsertRowsAbove(1); - Assert.IsTrue(dv.Ranges.Single().RangeAddress.IsValid); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", dv.Ranges.Single().RangeAddress.ToString()); + ws.Row(2).InsertRowsAbove(1); + Assert.IsTrue(dv.Ranges.Single().RangeAddress.IsValid); + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", dv.Ranges.Single().RangeAddress.ToString()); - ws.Column(2).InsertColumnsAfter(1); - Assert.IsTrue(dv.Ranges.Single().RangeAddress.IsValid); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", dv.Ranges.Single().RangeAddress.ToString()); - } + ws.Column(2).InsertColumnsAfter(1); + Assert.IsTrue(dv.Ranges.Single().RangeAddress.IsValid); + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", dv.Ranges.Single().RangeAddress.ToString()); } } } diff --git a/ClosedXML.Tests/Excel/DataValidations/DataValidationTests.cs b/ClosedXML.Tests/Excel/DataValidations/DataValidationTests.cs index 99e011e17..d9d4072c0 100644 --- a/ClosedXML.Tests/Excel/DataValidations/DataValidationTests.cs +++ b/ClosedXML.Tests/Excel/DataValidations/DataValidationTests.cs @@ -12,9 +12,9 @@ public class DataValidationTests [Test] public void Validation_1() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Data Validation Issue"); - IXLCell cell = ws.Cell("E1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Data Validation Issue"); + var cell = ws.Cell("E1"); cell.SetValue("Value 1"); cell = cell.CellBelow(); cell.SetValue("Value 2"); @@ -60,12 +60,12 @@ public void Validation_1() [Test] public void Validation_2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("A"); ws.Cell("B1").CreateDataValidation().Custom("Sheet1!A1"); - IXLWorksheet ws2 = wb.AddWorksheet("Sheet2"); + var ws2 = wb.AddWorksheet("Sheet2"); ws2.Cell("A1").SetValue("B"); ws.Cell("B1").CopyTo(ws2.Cell("B1")); @@ -75,8 +75,8 @@ public void Validation_2() [Test, Ignore("Wait for proper formula shifting (#686)")] public void Validation_3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("A"); ws.Cell("B1").CreateDataValidation().Custom("A1"); ws.FirstRow().InsertRowsAbove(1); @@ -87,8 +87,8 @@ public void Validation_3() [Test] public void Validation_4() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("A"); ws.Cell("B1").CreateDataValidation().Custom("A1"); ws.Cell("B1").CopyTo(ws.Cell("B2")); @@ -98,8 +98,8 @@ public void Validation_4() [Test, Ignore("Wait for proper formula shifting (#686)")] public void Validation_5() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("A"); ws.Cell("B1").CreateDataValidation().Custom("A1"); ws.FirstColumn().InsertColumnsBefore(1); @@ -110,8 +110,8 @@ public void Validation_5() [Test] public void Validation_6() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("A"); ws.Cell("B1").CreateDataValidation().Custom("A1"); ws.Cell("B1").CopyTo(ws.Cell("C1")); @@ -121,16 +121,16 @@ public void Validation_6() [Test] public void Validation_persists_on_Cell_DataValidation() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("People"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("People"); ws.FirstCell().SetValue("Categories") .CellBelow().SetValue("A") .CellBelow().SetValue("B"); - IXLTable table = ws.RangeUsed().CreateTable(); + var table = ws.RangeUsed().CreateTable(); - IXLDataValidation dv = table.DataRange.CreateDataValidation(); + var dv = table.DataRange.CreateDataValidation(); dv.ErrorTitle = "Error"; Assert.AreEqual("Error", table.DataRange.FirstCell().GetDataValidation().ErrorTitle); @@ -139,15 +139,15 @@ public void Validation_persists_on_Cell_DataValidation() [Test] public void Validation_persists_on_Worksheet_DataValidations() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("People"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("People"); ws.FirstCell().SetValue("Categories") .CellBelow().SetValue("A"); - IXLTable table = ws.RangeUsed().CreateTable(); + var table = ws.RangeUsed().CreateTable(); - IXLDataValidation dv = table.DataRange.CreateDataValidation(); + var dv = table.DataRange.CreateDataValidation(); dv.ErrorTitle = "Error"; Assert.AreEqual("Error", ws.DataValidations.Single().ErrorTitle); @@ -163,12 +163,14 @@ public void Validation_persists_on_Worksheet_DataValidations() public void DataValidationShiftedOnRowInsert(string initialAddress, int rowNum, bool setValue, string expectedAddress) { //Arrange - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("DataValidation"); var validation = ws.Range(initialAddress).CreateDataValidation(); validation.WholeNumber.Between(0, 100); if (setValue) + { ws.Range(initialAddress).Value = 50; + } //Act ws.Row(rowNum).InsertRowsAbove(1); @@ -189,12 +191,14 @@ public void DataValidationShiftedOnRowInsert(string initialAddress, int rowNum, public void DataValidationShiftedOnColumnInsert(string initialAddress, int columnNum, bool setValue, string expectedAddress) { //Arrange - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("DataValidation"); var validation = ws.Range(initialAddress).CreateDataValidation(); validation.WholeNumber.Between(0, 100); if (setValue) + { ws.Range(initialAddress).Value = 50; + } //Act ws.Column(columnNum).InsertColumnsBefore(1); @@ -208,39 +212,35 @@ public void DataValidationShiftedOnColumnInsert(string initialAddress, int colum [Test] public void DataValidationClearSplitsRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("DataValidation"); - var validation = ws.Range("A1:C3").CreateDataValidation(); - validation.WholeNumber.Between(0, 100); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("DataValidation"); + var validation = ws.Range("A1:C3").CreateDataValidation(); + validation.WholeNumber.Between(0, 100); - //Act - ws.Cell("B2").Clear(XLClearOptions.DataValidation); + //Act + ws.Cell("B2").Clear(XLClearOptions.DataValidation); - //Assert - Assert.IsFalse(ws.Cell("B2").HasDataValidation); - Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2").All(c => c.HasDataValidation)); - } + //Assert + Assert.IsFalse(ws.Cell("B2").HasDataValidation); + Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2").All(c => c.HasDataValidation)); } [Test] public void NewDataValidationSplitsRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("DataValidation"); - var validation = ws.Range("A1:C3").CreateDataValidation(); - validation.WholeNumber.Between(10, 100); - - //Act - ws.Cell("B2").CreateDataValidation().WholeNumber.Between(-100, -0); - - //Assert - Assert.AreEqual("-100", ws.Cell("B2").GetDataValidation().MinValue); - Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2").All(c => c.HasDataValidation)); - Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2") - .All(c => c.GetDataValidation().MinValue == "10")); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("DataValidation"); + var validation = ws.Range("A1:C3").CreateDataValidation(); + validation.WholeNumber.Between(10, 100); + + //Act + ws.Cell("B2").CreateDataValidation().WholeNumber.Between(-100, -0); + + //Assert + Assert.AreEqual("-100", ws.Cell("B2").GetDataValidation().MinValue); + Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2").All(c => c.HasDataValidation)); + Assert.IsTrue(ws.Range("A1:C3").Cells().Where(c => c.Address.ToString() != "B2") + .All(c => c.GetDataValidation().MinValue == "10")); } [Test] @@ -251,23 +251,21 @@ public void ListLengthOverflow() Assert.True(values.Length > 255); - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var dv = wb.AddWorksheet("Sheet 1").Cell(1, 1).GetDataValidation(); + + Assert.Throws(() => dv.List(values)); + Assert.Throws(() => { - var dv = wb.AddWorksheet("Sheet 1").Cell(1, 1).GetDataValidation(); - - Assert.Throws(() => dv.List(values)); - Assert.Throws(() => - { - dv.TextLength.Between(0, 5); - dv.MinValue = values; - }); - - Assert.Throws(() => - { - dv.TextLength.Between(0, 5); - dv.MaxValue = values; - }); - } + dv.TextLength.Between(0, 5); + dv.MinValue = values; + }); + + Assert.Throws(() => + { + dv.TextLength.Between(0, 5); + dv.MaxValue = values; + }); } [Test] @@ -279,205 +277,183 @@ public void CannotCreateDataValidationWithoutRange() [Test] public void DataValidationHasWorksheetAndRangesWhenCreated() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range = ws.Range("A1:A3"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range = ws.Range("A1:A3"); - var dv = new XLDataValidation(range); + var dv = new XLDataValidation(range); - Assert.AreSame(ws, dv.Worksheet); - Assert.AreSame(range, dv.Ranges.Single()); - } + Assert.AreSame(ws, dv.Worksheet); + Assert.AreSame(range, dv.Ranges.Single()); } [Test] public void CanAddRangeFromSameWorksheet() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var ranges3 = ws.Ranges("D1:D3,F1:F3"); - var dv = new XLDataValidation(range1); - - dv.AddRange(range2); - dv.AddRanges(ranges3); - - Assert.IsTrue(dv.Ranges.Any(r => r == range1)); - Assert.IsTrue(dv.Ranges.Any(r => r == range2)); - Assert.IsTrue(dv.Ranges.Any(r => r == ranges3.First())); - Assert.IsTrue(dv.Ranges.Any(r => r == ranges3.Last())); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var ranges3 = ws.Ranges("D1:D3,F1:F3"); + var dv = new XLDataValidation(range1); + + dv.AddRange(range2); + dv.AddRanges(ranges3); + + Assert.IsTrue(dv.Ranges.Any(r => r == range1)); + Assert.IsTrue(dv.Ranges.Any(r => r == range2)); + Assert.IsTrue(dv.Ranges.Any(r => r == ranges3.First())); + Assert.IsTrue(dv.Ranges.Any(r => r == ranges3.Last())); } [Test] public void CanAddRangeFromAnotherWorksheet() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet(); - var ws2 = wb.AddWorksheet(); - var range1 = ws1.Range("A1:A3"); - var range2 = ws2.Range("C1:C3"); - var dv = new XLDataValidation(range1); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet(); + var ws2 = wb.AddWorksheet(); + var range1 = ws1.Range("A1:A3"); + var range2 = ws2.Range("C1:C3"); + var dv = new XLDataValidation(range1); - dv.AddRange(range2); + dv.AddRange(range2); - Assert.IsTrue(dv.Ranges.Any(r => r != range2 && r.RangeAddress.ToString() == range2.RangeAddress.ToString())); - } + Assert.IsTrue(dv.Ranges.Any(r => r != range2 && r.RangeAddress.ToString() == range2.RangeAddress.ToString())); } [Test] public void CanClearRanges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var ranges3 = ws.Ranges("D1:D3,F1:F3"); - var dv = new XLDataValidation(range1); - dv.AddRange(range2); - dv.AddRanges(ranges3); - - dv.ClearRanges(); - - Assert.IsEmpty(dv.Ranges); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var ranges3 = ws.Ranges("D1:D3,F1:F3"); + var dv = new XLDataValidation(range1); + dv.AddRange(range2); + dv.AddRanges(ranges3); + + dv.ClearRanges(); + + Assert.IsEmpty(dv.Ranges); } [Test] public void CanRemoveExistingRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); - dv.AddRange(range2); + var dv = new XLDataValidation(range1); + dv.AddRange(range2); - dv.RemoveRange(range1); + dv.RemoveRange(range1); - Assert.AreSame(range2, dv.Ranges.Single()); - } + Assert.AreSame(range2, dv.Ranges.Single()); } [Test] public void RemovingExistingRangeDoesNoFail() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); + var dv = new XLDataValidation(range1); - dv.RemoveRange(range2); - dv.RemoveRange(null); + dv.RemoveRange(range2); + dv.RemoveRange(null); - Assert.AreSame(range1, dv.Ranges.Single()); - } + Assert.AreSame(range1, dv.Ranges.Single()); } [Test] public void AddRangeFiresEvent() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var dv = new XLDataValidation(range1); - IXLRange addedRange = null; + IXLRange addedRange = null; - dv.RangeAdded += (s, e) => addedRange = e.Range; + dv.RangeAdded += (_, e) => addedRange = e.Range; - dv.AddRange(range2); + dv.AddRange(range2); - Assert.AreSame(range2, addedRange); - } + Assert.AreSame(range2, addedRange); } [Test] public void AddRangesFiresMultipleEvents() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var ranges = ws.Ranges("D1:D3,F1:F3"); - var dv = new XLDataValidation(range1); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var ranges = ws.Ranges("D1:D3,F1:F3"); + var dv = new XLDataValidation(range1); - var addedRanges = new List(); + var addedRanges = new List(); - dv.RangeAdded += (s, e) => addedRanges.Add(e.Range); + dv.RangeAdded += (_, e) => addedRanges.Add(e.Range); - dv.AddRanges(ranges); + dv.AddRanges(ranges); - Assert.AreEqual(2, addedRanges.Count); - } + Assert.AreEqual(2, addedRanges.Count); } [Test] public void RemoveRangeFiresEvent() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); - dv.AddRange(range2); - IXLRange removedRange = null; - dv.RangeRemoved += (s, e) => removedRange = e.Range; - - dv.RemoveRange(range2); - - Assert.AreSame(range2, removedRange); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var dv = new XLDataValidation(range1); + dv.AddRange(range2); + IXLRange removedRange = null; + dv.RangeRemoved += (s, e) => removedRange = e.Range; + + dv.RemoveRange(range2); + + Assert.AreSame(range2, removedRange); } [Test] public void RemoveNonExistingRangeDoesNotFireEvent() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var dv = new XLDataValidation(range1); - dv.RangeRemoved += (s, e) => Assert.Fail("Expected not to fire event"); + dv.RangeRemoved += (s, e) => Assert.Fail("Expected not to fire event"); - dv.RemoveRange(range2); - } + dv.RemoveRange(range2); } [Test] public void ClearRangesFiresMultipleEvents() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var range1 = ws.Range("A1:A3"); - var range2 = ws.Range("C1:C3"); - var dv = new XLDataValidation(range1); - dv.AddRange(range2); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var range1 = ws.Range("A1:A3"); + var range2 = ws.Range("C1:C3"); + var dv = new XLDataValidation(range1); + dv.AddRange(range2); - var removedRanges = new List(); + var removedRanges = new List(); - dv.RangeRemoved += (s, e) => removedRanges.Add(e.Range); + dv.RangeRemoved += (s, e) => removedRanges.Add(e.Range); - dv.ClearRanges(); + dv.ClearRanges(); - Assert.AreEqual(2, removedRanges.Count); - } + Assert.AreEqual(2, removedRanges.Count); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/DataValidations/XLDataValidationsTests.cs b/ClosedXML.Tests/Excel/DataValidations/XLDataValidationsTests.cs index a3ba2e0db..5bf24ccba 100644 --- a/ClosedXML.Tests/Excel/DataValidations/XLDataValidationsTests.cs +++ b/ClosedXML.Tests/Excel/DataValidations/XLDataValidationsTests.cs @@ -16,24 +16,22 @@ public void CannotCreateWithoutWorksheet() [Test] public void AddedRangesAreTransferredToTargetSheet() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet(); - var ws2 = wb.AddWorksheet(); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet(); + var ws2 = wb.AddWorksheet(); - var dv1 = ws1.Range("A1:A3").CreateDataValidation(); - dv1.MinValue = "100"; + var dv1 = ws1.Range("A1:A3").CreateDataValidation(); + dv1.MinValue = "100"; - var dv2 = ws2.DataValidations.Add(dv1); + var dv2 = ws2.DataValidations.Add(dv1); - Assert.AreEqual(1, ws1.DataValidations.Count()); - Assert.AreEqual(1, ws2.DataValidations.Count()); + Assert.AreEqual(1, ws1.DataValidations.Count()); + Assert.AreEqual(1, ws2.DataValidations.Count()); - Assert.AreNotSame(dv1, dv2); + Assert.AreNotSame(dv1, dv2); - Assert.AreSame(ws1, dv1.Ranges.Single().Worksheet); - Assert.AreSame(ws2, dv2.Ranges.Single().Worksheet); - } + Assert.AreSame(ws1, dv1.Ranges.Single().Worksheet); + Assert.AreSame(ws2, dv2.Ranges.Single().Worksheet); } [TestCase("A1:A1", true)] @@ -44,21 +42,23 @@ public void AddedRangesAreTransferredToTargetSheet() [TestCase("A1:C3", false)] public void CanFindDataValidationForRange(string searchAddress, bool expectedResult) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var dv = ws.Range("A1:A3").CreateDataValidation(); + dv.MinValue = "100"; + dv.AddRange(ws.Range("C1:C3")); + + var address = new XLRangeAddress(ws as XLWorksheet, searchAddress); + + var actualResult = ws.DataValidations.TryGet(address, out var foundDv); + Assert.AreEqual(expectedResult, actualResult); + if (expectedResult) { - var ws = wb.AddWorksheet(); - var dv = ws.Range("A1:A3").CreateDataValidation(); - dv.MinValue = "100"; - dv.AddRange(ws.Range("C1:C3")); - - var address = new XLRangeAddress(ws as XLWorksheet, searchAddress); - - var actualResult = ws.DataValidations.TryGet(address, out var foundDv); - Assert.AreEqual(expectedResult, actualResult); - if (expectedResult) - Assert.AreSame(dv, foundDv); - else - Assert.IsNull(foundDv); + Assert.AreSame(dv, foundDv); + } + else + { + Assert.IsNull(foundDv); } } @@ -71,81 +71,73 @@ public void CanFindDataValidationForRange(string searchAddress, bool expectedRes [TestCase("E2:E3", 0)] public void CanGetAllDataValidationsForRange(string searchAddress, int expectedCount) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var dv1 = ws.Range("A1:A3").CreateDataValidation(); - dv1.MinValue = "100"; - dv1.AddRange(ws.Range("C1:C3")); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var dv1 = ws.Range("A1:A3").CreateDataValidation(); + dv1.MinValue = "100"; + dv1.AddRange(ws.Range("C1:C3")); - var dv2 = ws.Range("E4:G6").CreateDataValidation(); - dv2.MinValue = "200"; + var dv2 = ws.Range("E4:G6").CreateDataValidation(); + dv2.MinValue = "200"; - var address = new XLRangeAddress(ws as XLWorksheet, searchAddress); + var address = new XLRangeAddress(ws as XLWorksheet, searchAddress); - var actualResult = ws.DataValidations.GetAllInRange(address); + var actualResult = ws.DataValidations.GetAllInRange(address); - Assert.AreEqual(expectedCount, actualResult.Count()); - } + Assert.AreEqual(expectedCount, actualResult.Count()); } [Test] public void AddDataValidationSplitsExistingRanges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var dv1 = ws.Ranges("B2:G7,C11:C13").CreateDataValidation(); - dv1.MinValue = "100"; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var dv1 = ws.Ranges("B2:G7,C11:C13").CreateDataValidation(); + dv1.MinValue = "100"; - var dv2 = ws.Range("E4:G6").CreateDataValidation(); - dv2.MinValue = "100"; + var dv2 = ws.Range("E4:G6").CreateDataValidation(); + dv2.MinValue = "100"; - Assert.AreEqual(4, dv1.Ranges.Count()); - Assert.AreEqual("B2:G3,B4:D6,B7:G7,C11:C13", - string.Join(",", dv1.Ranges.Select(r => r.RangeAddress.ToString()))); - } + Assert.AreEqual(4, dv1.Ranges.Count()); + Assert.AreEqual("B2:G3,B4:D6,B7:G7,C11:C13", + string.Join(",", dv1.Ranges.Select(r => r.RangeAddress.ToString()))); } [Test] public void RemovedRangeExcludedFromIndex() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var dv = ws.Range("A1:A3").CreateDataValidation(); - dv.MinValue = "100"; - var range = ws.Range("C1:C3"); - dv.AddRange(range); - - dv.RemoveRange(range); - - var actualResult = ws.DataValidations.TryGet(range.RangeAddress, out var foundDv); - Assert.IsFalse(actualResult); - Assert.IsNull(foundDv); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var dv = ws.Range("A1:A3").CreateDataValidation(); + dv.MinValue = "100"; + var range = ws.Range("C1:C3"); + dv.AddRange(range); + + dv.RemoveRange(range); + + var actualResult = ws.DataValidations.TryGet(range.RangeAddress, out var foundDv); + Assert.IsFalse(actualResult); + Assert.IsNull(foundDv); } [Test] public void ConsolidatedDataValidationsAreUnsubscribed() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var dv1 = ws.Range("A1:A3").CreateDataValidation(); - dv1.MinValue = "100"; - var dv2 = ws.Range("B1:B3").CreateDataValidation(); - dv2.MinValue = "100"; - - (ws.DataValidations as XLDataValidations).Consolidate(); - dv1.AddRange(ws.Range("C1:C3")); - dv2.AddRange(ws.Range("D1:D3")); - - var consolidatedDv = ws.DataValidations.Single(); - Assert.AreSame(dv1, consolidatedDv); - Assert.True(ws.Cell("C1").HasDataValidation); - Assert.False(ws.Cell("D1").HasDataValidation); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var dv1 = ws.Range("A1:A3").CreateDataValidation(); + dv1.MinValue = "100"; + var dv2 = ws.Range("B1:B3").CreateDataValidation(); + dv2.MinValue = "100"; + + (ws.DataValidations as XLDataValidations).Consolidate(); + dv1.AddRange(ws.Range("C1:C3")); + dv2.AddRange(ws.Range("D1:D3")); + + var consolidatedDv = ws.DataValidations.Single(); + Assert.AreSame(dv1, consolidatedDv); + Assert.True(ws.Cell("C1").HasDataValidation); + Assert.False(ws.Cell("D1").HasDataValidation); } } } diff --git a/ClosedXML.Tests/Excel/Globalization/GlobalizationTests.cs b/ClosedXML.Tests/Excel/Globalization/GlobalizationTests.cs index b41432743..2872b138c 100644 --- a/ClosedXML.Tests/Excel/Globalization/GlobalizationTests.cs +++ b/ClosedXML.Tests/Excel/Globalization/GlobalizationTests.cs @@ -9,38 +9,36 @@ namespace ClosedXML.Tests.Excel.Globalization public class GlobalizationTests { [Test] - [TestCase("A1*10", 1230d)] - [TestCase("A1/10", 12.3)] - [TestCase("A1&\" cells\"", "123 cells")] - [TestCase("A1&\"000\"", "123000")] - [TestCase("ISNUMBER(A1)", true)] - [TestCase("ISBLANK(A1)", false)] - [TestCase("DATE(2018,1,28)", 43128d)] - public void LoadFormulaCachedValue(string formula, object expectedValue) + [TestCase("A1*10", 1230d, "1230")] + [TestCase("A1/10", 12.3, "12.3")] + [TestCase("A1&\" cells\"", "123 cells", "123 cells")] + [TestCase("A1&\"000\"", "123000", "123000")] + [TestCase("ISNUMBER(A1)", true, "true")] + [TestCase("ISBLANK(A1)", false, "false")] + [TestCase("DATE(2018,1,28)", 43128d, "43128")] + public void LoadFormulaCachedValue(string formula, object expectedValue, string expectedInnerText) { Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("ru-RU"); - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var book1 = new XLWorkbook()) { - using (XLWorkbook book1 = new XLWorkbook()) - { - var sheet = book1.AddWorksheet("sheet1"); - sheet.Cell("A1").Value = 123; - sheet.Cell("A2").FormulaA1 = formula; - var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; + var sheet = book1.AddWorksheet("sheet1"); + sheet.Cell("A1").Value = 123; + sheet.Cell("A2").FormulaA1 = formula; + var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; - book1.SaveAs(ms, options); - } - ms.Position = 0; - - using (XLWorkbook book2 = new XLWorkbook(ms)) - { - var ws = book2.Worksheet(1); - var storedValueA2 = ws.Cell("A2").CachedValue; - Assert.IsFalse(ws.Cell("A2").NeedsRecalculation); - Assert.AreEqual(expectedValue, storedValueA2); - } + book1.SaveAs(ms, options); } + ms.Position = 0; + + using var book2 = new XLWorkbook(ms); + var ws = book2.Worksheet(1); + var cellA2 = (XLCell)ws.Cell("A2"); + + Assert.That(cellA2.InnerText, Is.EqualTo(expectedInnerText)); + Assert.That(cellA2.CachedValue, Is.EqualTo(expectedValue)); + Assert.That(cellA2.NeedsRecalculation, Is.False); } } } diff --git a/ClosedXML.Tests/Excel/ImageHandling/PictureTests.cs b/ClosedXML.Tests/Excel/ImageHandling/PictureTests.cs index 164db7c95..26595b714 100644 --- a/ClosedXML.Tests/Excel/ImageHandling/PictureTests.cs +++ b/ClosedXML.Tests/Excel/ImageHandling/PictureTests.cs @@ -1,14 +1,15 @@ using ClosedXML.Excel; using ClosedXML.Excel.Drawings; using NUnit.Framework; +using SkiaSharp; using System; -using System.Drawing; + using System.IO; using System.Linq; using System.Reflection; using System.Threading.Tasks; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.ImageHandling { [TestFixture] public class PictureTests @@ -16,77 +17,69 @@ public class PictureTests [Test] public void CanAddPictureFromBitmap() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - - using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap) - { - var picture = ws.AddPicture(bitmap, "MyPicture") - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50) - .WithSize(200, 200); - - Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); - Assert.AreEqual(200, picture.Width); - Assert.AreEqual(200, picture.Height); - } - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + using var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg"); + using var bitmap = SKCodec.Create(resourceStream); + var picture = ws.AddPicture(bitmap, "MyPicture") + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50.1f, 50.1f) + .WithSize(200, 200); + + Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); + Assert.AreEqual(200, picture.Width); + Assert.AreEqual(200, picture.Height); } [Test] public void CanAddPictureFromStream() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - - using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - { - var picture = ws.AddPicture(resourceStream, "MyPicture") - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50) - .WithSize(200, 200); - - Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); - Assert.AreEqual(200, picture.Width); - Assert.AreEqual(200, picture.Height); - } - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + using var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg"); + var picture = ws.AddPicture(resourceStream, "MyPicture") + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50, 50) + .WithSize(200, 200); + + Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); + Assert.AreEqual(200, picture.Width); + Assert.AreEqual(200, picture.Height); } [Test] public void CanAddPictureFromFile() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var path = Path.ChangeExtension(Path.GetTempFileName(), "jpg"); + var path = Path.ChangeExtension(Path.GetTempFileName(), "jpg"); - try + try + { + using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) + using (var fileStream = File.Create(path)) { - using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - using (var fileStream = File.Create(path)) - { - resourceStream.Seek(0, SeekOrigin.Begin); - resourceStream.CopyTo(fileStream); - fileStream.Close(); - } - - var picture = ws.AddPicture(path) - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50); - - Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); - Assert.AreEqual(400, picture.Width); - Assert.AreEqual(400, picture.Height); + resourceStream.Seek(0, SeekOrigin.Begin); + resourceStream.CopyTo(fileStream); + fileStream.Close(); } - finally + + var picture = ws.AddPicture(path) + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50, 50); + + Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); + Assert.AreEqual(400, picture.Width); + Assert.AreEqual(400, picture.Height); + } + finally + { + if (File.Exists(path)) { - if (File.Exists(path)) - File.Delete(path); + File.Delete(path); } } } @@ -119,128 +112,118 @@ public void CanAddPictureConcurrentlyFromFile() private void verifyAddImageFromFile(string filePath) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var picture = ws.AddPicture(filePath) - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50); + var picture = ws.AddPicture(filePath) + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50, 50); - Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); - Assert.AreEqual(400, picture.Width); - Assert.AreEqual(50, picture.Top); - } + Assert.AreEqual(XLPictureFormat.Jpeg, picture.Format); + Assert.AreEqual(400, picture.Width); + Assert.AreEqual(50, picture.Top); } [Test] public void CanScaleImage() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - - using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - var pic = ws.AddPicture(resourceStream, "MyPicture") - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50); - - Assert.AreEqual(252, pic.OriginalWidth); - Assert.AreEqual(152, pic.OriginalHeight); - Assert.AreEqual(252, pic.Width); - Assert.AreEqual(152, pic.Height); - - pic.ScaleHeight(0.7); - pic.ScaleWidth(1.2); - - Assert.AreEqual(252, pic.OriginalWidth); - Assert.AreEqual(152, pic.OriginalHeight); - Assert.AreEqual(302, pic.Width); - Assert.AreEqual(106, pic.Height); - - pic.ScaleHeight(0.7); - pic.ScaleWidth(1.2); - - Assert.AreEqual(252, pic.OriginalWidth); - Assert.AreEqual(152, pic.OriginalHeight); - Assert.AreEqual(362, pic.Width); - Assert.AreEqual(74, pic.Height); - - pic.ScaleHeight(0.8, true); - pic.ScaleWidth(1.1, true); - - Assert.AreEqual(252, pic.OriginalWidth); - Assert.AreEqual(152, pic.OriginalHeight); - Assert.AreEqual(277, pic.Width); - Assert.AreEqual(122, pic.Height); - } - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + + using var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png"); + var pic = ws.AddPicture(resourceStream, "MyPicture") + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50, 50); + + Assert.AreEqual(252, pic.OriginalWidth); + Assert.AreEqual(152, pic.OriginalHeight); + Assert.AreEqual(252, pic.Width); + Assert.AreEqual(152, pic.Height); + + pic.ScaleHeight(0.7); + pic.ScaleWidth(1.2); + + Assert.AreEqual(252, pic.OriginalWidth); + Assert.AreEqual(152, pic.OriginalHeight); + Assert.AreEqual(302, pic.Width); + Assert.AreEqual(106, pic.Height); + + pic.ScaleHeight(0.7); + pic.ScaleWidth(1.2); + + Assert.AreEqual(252, pic.OriginalWidth); + Assert.AreEqual(152, pic.OriginalHeight); + Assert.AreEqual(362, pic.Width); + Assert.AreEqual(74, pic.Height); + + pic.ScaleHeight(0.8, true); + pic.ScaleWidth(1.1, true); + + Assert.AreEqual(252, pic.OriginalWidth); + Assert.AreEqual(152, pic.OriginalHeight); + Assert.AreEqual(277, pic.Width); + Assert.AreEqual(122, pic.Height); } [Test] public void TestDefaultPictureNames() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; + using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) + { + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; - ws.AddPicture(stream, XLPictureFormat.Png).Name = "Picture 4"; - stream.Position = 0; + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; - } + ws.AddPicture(stream, XLPictureFormat.Png).Name = "Picture 4"; + stream.Position = 0; - Assert.AreEqual("Picture 1", ws.Pictures.Skip(0).First().Name); - Assert.AreEqual("Picture 2", ws.Pictures.Skip(1).First().Name); - Assert.AreEqual("Picture 4", ws.Pictures.Skip(2).First().Name); - Assert.AreEqual("Picture 5", ws.Pictures.Skip(3).First().Name); + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; } + + Assert.AreEqual("Picture 1", ws.Pictures.Skip(0).First().Name); + Assert.AreEqual("Picture 2", ws.Pictures.Skip(1).First().Name); + Assert.AreEqual("Picture 4", ws.Pictures.Skip(2).First().Name); + Assert.AreEqual("Picture 5", ws.Pictures.Skip(3).First().Name); } [Test] public void TestDefaultIds() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; - - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; + using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) + { + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; - ws.AddPicture(stream, XLPictureFormat.Png).Name = "Picture 4"; - stream.Position = 0; + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; - ws.AddPicture(stream, XLPictureFormat.Png); - stream.Position = 0; - } + ws.AddPicture(stream, XLPictureFormat.Png).Name = "Picture 4"; + stream.Position = 0; - Assert.AreEqual(1, ws.Pictures.Skip(0).First().Id); - Assert.AreEqual(2, ws.Pictures.Skip(1).First().Id); - Assert.AreEqual(3, ws.Pictures.Skip(2).First().Id); - Assert.AreEqual(4, ws.Pictures.Skip(3).First().Id); + ws.AddPicture(stream, XLPictureFormat.Png); + stream.Position = 0; } + + Assert.AreEqual(1, ws.Pictures.Skip(0).First().Id); + Assert.AreEqual(2, ws.Pictures.Skip(1).First().Id); + Assert.AreEqual(3, ws.Pictures.Skip(2).First().Id); + Assert.AreEqual(4, ws.Pictures.Skip(3).First().Id); } [Test] public void XLMarkerTests() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - XLMarker firstMarker = new XLMarker(ws.Cell(1, 10), new Point(100, 0)); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var firstMarker = new XLMarker(ws.Cell(1, 10), new SKPoint(100, 0)); Assert.AreEqual(10, firstMarker.ColumnNumber); Assert.AreEqual(1, firstMarker.RowNumber); @@ -251,132 +234,141 @@ public void XLMarkerTests() [Test] public void XLPictureTests() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - var pic = ws.AddPicture(stream, XLPictureFormat.Png, "Image1") - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(220, 155); - - Assert.AreEqual(XLPicturePlacement.FreeFloating, pic.Placement); - Assert.AreEqual("Image1", pic.Name); - Assert.AreEqual(XLPictureFormat.Png, pic.Format); - Assert.AreEqual(252, pic.OriginalWidth); - Assert.AreEqual(152, pic.OriginalHeight); - Assert.AreEqual(252, pic.Width); - Assert.AreEqual(152, pic.Height); - Assert.AreEqual(220, pic.Left); - Assert.AreEqual(155, pic.Top); - } - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png"); + var pic = ws.AddPicture(stream, XLPictureFormat.Png, "Image1") + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(220, 155); + + Assert.AreEqual(XLPicturePlacement.FreeFloating, pic.Placement); + Assert.AreEqual("Image1", pic.Name); + Assert.AreEqual(XLPictureFormat.Png, pic.Format); + Assert.AreEqual(252, pic.OriginalWidth); + Assert.AreEqual(152, pic.OriginalHeight); + Assert.AreEqual(252, pic.Width); + Assert.AreEqual(152, pic.Height); + Assert.AreEqual(220, pic.Left); + Assert.AreEqual(155, pic.Top); } [Test] public void CanLoadFileWithImagesAndCopyImagesToNewSheet() { + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + Assert.AreEqual(2, ws.Pictures.Count); + + var copy = ws.CopyTo("NewSheet"); + Assert.AreEqual(2, copy.Pictures.Count); + } + + [Test] + public void CanDeletePictureOnlyOne() + { + using var ms = new MemoryStream(); + int originalCount; + using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) using (var wb = new XLWorkbook(stream)) { var ws = wb.Worksheets.First(); - Assert.AreEqual(2, ws.Pictures.Count); + originalCount = ws.Pictures.Count; + + ws.Pictures.Delete(ws.Pictures.First()); + wb.SaveAs(ms); + } - var copy = ws.CopyTo("NewSheet"); - Assert.AreEqual(2, copy.Pictures.Count); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.AreEqual(originalCount - 1, ws.Pictures.Count); } } [Test] public void CanDeletePictures() { - using (var ms = new MemoryStream()) - { - int originalCount; + using var ms = new MemoryStream(); + int originalCount; - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - originalCount = ws.Pictures.Count; - ws.Pictures.Delete(ws.Pictures.First()); + using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) + using (var wb = new XLWorkbook(stream)) + { + var ws = wb.Worksheets.First(); + originalCount = ws.Pictures.Count; + ws.Pictures.Delete(ws.Pictures.First()); - var pictureName = ws.Pictures.First().Name; - ws.Pictures.Delete(pictureName); + var pictureName = ws.Pictures.First().Name; + ws.Pictures.Delete(pictureName); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual(originalCount - 2, ws.Pictures.Count); - } + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.AreEqual(originalCount - 2, ws.Pictures.Count); } } [Test] public void PictureRenameTests() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("Images3"); - var picture = ws.Pictures.First(); - Assert.AreEqual("Picture 1", picture.Name); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("Images3"); + var picture = ws.Pictures.First(); + Assert.AreEqual("Picture 1", picture.Name); - picture.Name = "picture 1"; - picture.Name = "pICture 1"; - picture.Name = "Picture 1"; + picture.Name = "picture 1"; + picture.Name = "pICture 1"; + picture.Name = "Picture 1"; - picture = ws.Pictures.Last(); - picture.Name = "new name"; + picture = ws.Pictures.Last(); + picture.Name = "new name"; - Assert.Throws(() => picture.Name = "Picture 1"); - Assert.Throws(() => picture.Name = "picTURE 1"); - } + Assert.Throws(() => picture.Name = "Picture 1"); + Assert.Throws(() => picture.Name = "picTURE 1"); } [Test] public void HandleDuplicatePictureIdsAcrossWorksheets() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - var ws2 = wb.AddWorksheet("Sheet2"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + var ws2 = wb.AddWorksheet("Sheet2"); - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - (ws1 as XLWorksheet).AddPicture(stream, "Picture 1", 2); - (ws1 as XLWorksheet).AddPicture(stream, "Picture 2", 3); + using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png"); + (ws1 as XLWorksheet).AddPicture(stream, "Picture 1", 2); + (ws1 as XLWorksheet).AddPicture(stream, "Picture 2", 3); - //Internal method - used for loading files - var pic = (ws2 as XLWorksheet).AddPicture(stream, "Picture 1", 2) - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(220, 155) as XLPicture; + //Internal method - used for loading files + var pic = (ws2 as XLWorksheet).AddPicture(stream, "Picture 1", 2) + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(220, 155) as XLPicture; - var id = pic.Id; + var id = pic.Id; - pic.Id = id; - Assert.AreEqual(id, pic.Id); + pic.Id = id; + Assert.AreEqual(id, pic.Id); - pic.Id = 3; - Assert.AreEqual(3, pic.Id); + pic.Id = 3; + Assert.AreEqual(3, pic.Id); - pic.Id = id; + pic.Id = id; - var pic2 = (ws2 as XLWorksheet).AddPicture(stream, "Picture 2", 3) - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(440, 300) as XLPicture; - } - } + _ = (ws2 as XLWorksheet).AddPicture(stream, "Picture 2", 3) + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(440, 300) as XLPicture; } [Test] public void CopyImageSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); IXLPicture original; @@ -390,7 +382,7 @@ public void CopyImageSameWorksheet() var copy = original.Duplicate() .MoveTo(300, 200) as XLPicture; - Assert.AreEqual(2, ws1.Pictures.Count()); + Assert.AreEqual(2, ws1.Pictures.Count); Assert.AreEqual(ws1, copy.Worksheet); Assert.AreEqual(original.Format, copy.Format); Assert.AreEqual(original.Height, copy.Height); @@ -408,7 +400,7 @@ public void CopyImageSameWorksheet() [Test] public void CopyImageDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); IXLPicture original; using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) @@ -421,8 +413,8 @@ public void CopyImageDifferentWorksheets() var copy = original.CopyTo(ws2); - Assert.AreEqual(1, ws1.Pictures.Count()); - Assert.AreEqual(1, ws2.Pictures.Count()); + Assert.AreEqual(1, ws1.Pictures.Count); + Assert.AreEqual(1, ws2.Pictures.Count); Assert.AreEqual(ws2, copy.Worksheet); @@ -442,32 +434,30 @@ public void CopyImageDifferentWorksheets() [Test] public void PictureShiftsWhenInsertingRows() { - using (var wb = new XLWorkbook()) - using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png")) - { - var ws = wb.Worksheets.Add("ImageShift"); - var picture = ws.AddPicture(stream, XLPictureFormat.Png, "PngImage") - .MoveTo(ws.Cell(5, 2)) - .WithPlacement(XLPicturePlacement.Move); + using var wb = new XLWorkbook(); + using var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ClosedXML.Tests.Resource.Images.ImageHandling.png"); + var ws = wb.Worksheets.Add("ImageShift"); + var picture = ws.AddPicture(stream, XLPictureFormat.Png, "PngImage") + .MoveTo(ws.Cell(5, 2)) + .WithPlacement(XLPicturePlacement.Move); - ws.Row(2).InsertRowsBelow(20); + ws.Row(2).InsertRowsBelow(20); - Assert.AreEqual(25, picture.TopLeftCell.Address.RowNumber); - } + Assert.AreEqual(25, picture.TopLeftCell.Address.RowNumber); } [Test] public void PictureNotFound() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - Assert.Throws(() => ws.Picture("dummy")); - Assert.Throws(() => ws.Pictures.Delete("dummy")); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.Throws(() => ws.Picture("dummy")); + Assert.Throws(() => ws.Pictures.Delete("dummy")); } [Test] + // TODO: can this be handlled without getting height etc. of image? + [Ignore("SkiaSharp does not understand EMF as of https://github.com/mono/SkiaSharp/issues/1314 and at the moment there is no possibility to handle pictures without knowing the dimensions.")] public void CanCopyEmfPicture() { // #1621 - There are 2 Bmp Guids: ImageFormat.Bmp and ImageFormat.MemoryBmp @@ -493,4 +483,4 @@ public void CanCopyEmfPicture() Assert.AreEqual(XLPictureFormat.Emf, img2.Format); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/InsertData/ArrayTypeReaderTests.cs b/ClosedXML.Tests/Excel/InsertData/ArrayTypeReaderTests.cs index 90ee13712..3d17e0f92 100644 --- a/ClosedXML.Tests/Excel/InsertData/ArrayTypeReaderTests.cs +++ b/ClosedXML.Tests/Excel/InsertData/ArrayTypeReaderTests.cs @@ -45,4 +45,4 @@ public void CanReadValues() Assert.AreEqual(6, result.Last().Last()); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/InsertData/DataRecordReaderTests.cs b/ClosedXML.Tests/Excel/InsertData/DataRecordReaderTests.cs index b7e481850..42190808c 100644 --- a/ClosedXML.Tests/Excel/InsertData/DataRecordReaderTests.cs +++ b/ClosedXML.Tests/Excel/InsertData/DataRecordReaderTests.cs @@ -20,25 +20,21 @@ union all union all select 'Value 3', 300"; - using (var connection = new SqlConnection(_connectionString)) - using (var command = new SqlCommand(queryString, connection)) + using var connection = new SqlConnection(_connectionString); + using var command = new SqlCommand(queryString, connection); + try { - try - { - connection.Open(); - } - catch - { - Assert.Ignore("Could not connect to localdb"); - } + connection.Open(); + } + catch + { + Assert.Ignore("Could not connect to localdb"); + } - using (var reader = command.ExecuteReader()) - { - while (reader.Read()) - { - yield return reader; - } - } + using var reader = command.ExecuteReader(); + while (reader.Read()) + { + yield return reader; } } diff --git a/ClosedXML.Tests/Excel/InsertData/InsertDataReaderFactoryTests.cs b/ClosedXML.Tests/Excel/InsertData/InsertDataReaderFactoryTests.cs index 411859556..53e76c039 100644 --- a/ClosedXML.Tests/Excel/InsertData/InsertDataReaderFactoryTests.cs +++ b/ClosedXML.Tests/Excel/InsertData/InsertDataReaderFactoryTests.cs @@ -118,7 +118,7 @@ public void CanCreateSimpleReaderFromIEnumerableOfString() [Test] public void CanCreateDataTableReader() { - var dt = new DataTable(); + using var dt = new DataTable(); var reader = InsertDataReaderFactory.Instance.CreateReader(dt); Assert.IsInstanceOf(reader); @@ -160,8 +160,10 @@ public void CanCreateUntypedObjectReader() Assert.IsInstanceOf(reader); } - private class TestEntity { } + private class TestEntity + { } - private struct TestStruct { } + private struct TestStruct + { } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/InsertData/ObjectReaderTests.cs b/ClosedXML.Tests/Excel/InsertData/ObjectReaderTests.cs index a4ebc8807..205939478 100644 --- a/ClosedXML.Tests/Excel/InsertData/ObjectReaderTests.cs +++ b/ClosedXML.Tests/Excel/InsertData/ObjectReaderTests.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel.InsertData; +using ClosedXML.Tests.Excel.Tables; using NUnit.Framework; using System.Collections; using System.Collections.Generic; diff --git a/ClosedXML.Tests/Excel/InsertData/UntypedObjectReaderTests.cs b/ClosedXML.Tests/Excel/InsertData/UntypedObjectReaderTests.cs index 4c6984d29..804cd9636 100644 --- a/ClosedXML.Tests/Excel/InsertData/UntypedObjectReaderTests.cs +++ b/ClosedXML.Tests/Excel/InsertData/UntypedObjectReaderTests.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel.InsertData; +using ClosedXML.Tests.Excel.Tables; using NUnit.Framework; using System.Collections; using System.Linq; @@ -74,4 +75,4 @@ public void CanGetData() Assert.AreEqual(new object[] { "Value 9", "Value 10" }, result[8]); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Loading/LoadingTests.cs b/ClosedXML.Tests/Excel/Loading/LoadingTests.cs index 8eb861b53..79b2324e9 100644 --- a/ClosedXML.Tests/Excel/Loading/LoadingTests.cs +++ b/ClosedXML.Tests/Excel/Loading/LoadingTests.cs @@ -7,7 +7,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Loading { // Tests in this fixture test only the successful loading of existing Excel files, // i.e. we test that ClosedXML doesn't choke on a given input file @@ -67,40 +67,48 @@ private static IEnumerable LOFiles [Test] public void CanLoadAndManipulateFileWithEmptyTable() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyTable.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); - table.DataRange.InsertRowsBelow(5); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyTable.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + var table = ws.Tables.First(); + table.DataRange.InsertRowsBelow(5); + } + + [Test] + public void CanLoadAndSaveCommentAsNoteWithNoTextBox() + { + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CommentAsNoteWithNoTextBox.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + Assert.AreEqual("Author:\r\nbla", ws.Cell("A3").GetComment().Text); + + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } [Test] public void CanLoadDate1904SystemCorrectly() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\Date1904System.xlsx"))) - using (var ms = new MemoryStream()) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\Date1904System.xlsx")); + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook(stream)) { - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - var c = ws.Cell("A2"); - Assert.AreEqual(XLDataType.DateTime, c.DataType); - Assert.AreEqual(new DateTime(2017, 10, 27, 21, 0, 0), c.GetDateTime()); - wb.SaveAs(ms); - } + var ws = wb.Worksheets.First(); + var c = ws.Cell("A2"); + Assert.AreEqual(XLDataType.DateTime, c.DataType); + Assert.AreEqual(new DateTime(2017, 10, 27, 21, 0, 0), c.GetDateTime()); + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var c = ws.Cell("A2"); - Assert.AreEqual(XLDataType.DateTime, c.DataType); - Assert.AreEqual(new DateTime(2017, 10, 27, 21, 0, 0), c.GetDateTime()); - wb.SaveAs(ms); - } + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var c = ws.Cell("A2"); + Assert.AreEqual(XLDataType.DateTime, c.DataType); + Assert.AreEqual(new DateTime(2017, 10, 27, 21, 0, 0), c.GetDateTime()); + wb.SaveAs(ms); } } @@ -110,67 +118,57 @@ public void CanLoadAndSaveFileWithMismatchingSheetIdAndRelId() // This file's workbook.xml contains: // // and the mismatch between the sheetId and r:id can create problems. - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithMismatchSheetIdAndRelId.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - } - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithMismatchSheetIdAndRelId.xlsx")); + using var wb = new XLWorkbook(stream); + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } [Test] public void CanLoadBasicPivotTable() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("PivotTable1"); - var pt = ws.PivotTable("PivotTable1"); - Assert.AreEqual("PivotTable1", pt.Name); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PivotTable1"); + var pt = ws.PivotTable("PivotTable1"); + Assert.AreEqual("PivotTable1", pt.Name); - Assert.AreEqual(1, pt.RowLabels.Count()); - Assert.AreEqual("Name", pt.RowLabels.Single().SourceName); + Assert.AreEqual(1, pt.RowLabels.Count()); + Assert.AreEqual("Name", pt.RowLabels.Single().SourceName); - Assert.AreEqual(1, pt.ColumnLabels.Count()); - Assert.AreEqual("Month", pt.ColumnLabels.Single().SourceName); + Assert.AreEqual(1, pt.ColumnLabels.Count()); + Assert.AreEqual("Month", pt.ColumnLabels.Single().SourceName); - var pv = pt.Values.Single(); - Assert.AreEqual("Sum of NumberOfOrders", pv.CustomName); - Assert.AreEqual("NumberOfOrders", pv.SourceName); - } + var pv = pt.Values.Single(); + Assert.AreEqual("Sum of NumberOfOrders", pv.CustomName); + Assert.AreEqual("NumberOfOrders", pv.SourceName); } [Test] public void CanLoadOrderedPivotTable() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("OrderedPivotTable"); - var pt = ws.PivotTable("OrderedPivotTable"); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("OrderedPivotTable"); + var pt = ws.PivotTable("OrderedPivotTable"); - Assert.AreEqual(XLPivotSortType.Ascending, pt.RowLabels.Single().SortType); - Assert.AreEqual(XLPivotSortType.Descending, pt.ColumnLabels.Single().SortType); - } + Assert.AreEqual(XLPivotSortType.Ascending, pt.RowLabels.Single().SortType); + Assert.AreEqual(XLPivotSortType.Descending, pt.ColumnLabels.Single().SortType); } [Test] public void CanLoadPivotTableSubtotals() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("PivotTableSubtotals"); - var pt = ws.PivotTable("PivotTableSubtotals"); - - var subtotals = pt.RowLabels.Get("Group").Subtotals.ToArray(); - Assert.AreEqual(3, subtotals.Length); - Assert.AreEqual(XLSubtotalFunction.Average, subtotals[0]); - Assert.AreEqual(XLSubtotalFunction.Count, subtotals[1]); - Assert.AreEqual(XLSubtotalFunction.Sum, subtotals[2]); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LoadPivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PivotTableSubtotals"); + var pt = ws.PivotTable("PivotTableSubtotals"); + + var subtotals = pt.RowLabels.Get("Group").Subtotals.ToArray(); + Assert.AreEqual(3, subtotals.Length); + Assert.AreEqual(XLSubtotalFunction.Average, subtotals[0]); + Assert.AreEqual(XLSubtotalFunction.Count, subtotals[1]); + Assert.AreEqual(XLSubtotalFunction.Sum, subtotals[2]); } /// @@ -182,14 +180,10 @@ public void CanLoadPivotTableSubtotals() [Test] public void CanSaveFileWithDefaultStyleNameNotInEnglish() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithDefaultStyleNameNotInEnglish.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - } - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithDefaultStyleNameNotInEnglish.xlsx")); + using var wb = new XLWorkbook(stream); + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } /// @@ -201,48 +195,42 @@ public void CanSaveFileWithDefaultStyleNameNotInEnglish() [Test] public void CanLoadLibreOfficeFileWithDates() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LibreOfficeFileWithDates.xlsx"))) - using (var wb = new XLWorkbook(stream)) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LibreOfficeFileWithDates.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + foreach (var cell in ws.CellsUsed()) { - var ws = wb.Worksheets.First(); - foreach (var cell in ws.CellsUsed()) - { - Assert.AreEqual(XLDataType.DateTime, cell.DataType); - } + Assert.AreEqual(XLDataType.DateTime, cell.DataType); } } [Test] public void CanLoadFileWithImagesWithCorrectAnchorTypes() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual(2, ws.Pictures.Count); - Assert.AreEqual(XLPicturePlacement.FreeFloating, ws.Pictures.First().Placement); - Assert.AreEqual(XLPicturePlacement.Move, ws.Pictures.Skip(1).First().Placement); - - var ws2 = wb.Worksheets.Skip(1).First(); - Assert.AreEqual(1, ws2.Pictures.Count); - Assert.AreEqual(XLPicturePlacement.MoveAndSize, ws2.Pictures.First().Placement); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + Assert.AreEqual(2, ws.Pictures.Count); + Assert.AreEqual(XLPicturePlacement.FreeFloating, ws.Pictures.First().Placement); + Assert.AreEqual(XLPicturePlacement.Move, ws.Pictures.Skip(1).First().Placement); + + var ws2 = wb.Worksheets.Skip(1).First(); + Assert.AreEqual(1, ws2.Pictures.Count); + Assert.AreEqual(XLPicturePlacement.MoveAndSize, ws2.Pictures.First().Placement); } [Test] public void CanLoadFileWithImagesWithCorrectImageType() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageFormats.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual(1, ws.Pictures.Count); - Assert.AreEqual(XLPictureFormat.Jpeg, ws.Pictures.First().Format); - - var ws2 = wb.Worksheets.Skip(1).First(); - Assert.AreEqual(1, ws2.Pictures.Count); - Assert.AreEqual(XLPictureFormat.Png, ws2.Pictures.First().Format); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageFormats.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + Assert.AreEqual(1, ws.Pictures.Count); + Assert.AreEqual(XLPictureFormat.Jpeg, ws.Pictures.First().Format); + + var ws2 = wb.Worksheets.Skip(1).First(); + Assert.AreEqual(1, ws2.Pictures.Count); + Assert.AreEqual(XLPictureFormat.Png, ws2.Pictures.First().Format); } [Test] @@ -251,40 +239,36 @@ public void CanLoadAndDeduceAnchorsFromExcelGeneratedFile() // This file was produced by Excel. It contains 3 images, but the latter 2 were copied from the first. // There is actually only 1 embedded image if you inspect the file's internals. // Additionally, Excel saves all image anchors as TwoCellAnchor, but uses the EditAs attribute to distinguish the types - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\ExcelProducedWorkbookWithImages.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual(3, ws.Pictures.Count); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\ExcelProducedWorkbookWithImages.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + Assert.AreEqual(3, ws.Pictures.Count); - Assert.AreEqual(XLPicturePlacement.MoveAndSize, ws.Picture("Picture 1").Placement); - Assert.AreEqual(XLPicturePlacement.Move, ws.Picture("Picture 2").Placement); - Assert.AreEqual(XLPicturePlacement.FreeFloating, ws.Picture("Picture 3").Placement); + Assert.AreEqual(XLPicturePlacement.MoveAndSize, ws.Picture("Picture 1").Placement); + Assert.AreEqual(XLPicturePlacement.Move, ws.Picture("Picture 2").Placement); + Assert.AreEqual(XLPicturePlacement.FreeFloating, ws.Picture("Picture 3").Placement); - using (var ms = new MemoryStream()) - wb.SaveAs(ms, true); - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } [Test] public void CanLoadFromTemplate() { - using (var tf1 = new TemporaryFile()) - using (var tf2 = new TemporaryFile()) + using var tf1 = new TemporaryFile(); + using var tf2 = new TemporaryFile(); + using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\AllShapes.xlsx"))) + using (var wb = new XLWorkbook(stream)) { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\AllShapes.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - // Save as temporary file - wb.SaveAs(tf1.Path); - } + // Save as temporary file + wb.SaveAs(tf1.Path); + } - var workbook = XLWorkbook.OpenFromTemplate(tf1.Path); - Assert.True(workbook.Worksheets.Any()); - Assert.Throws(() => workbook.Save()); + using var workbook = XLWorkbook.OpenFromTemplate(tf1.Path); + Assert.True(workbook.Worksheets.Any()); + Assert.Throws(() => workbook.Save()); - workbook.SaveAs(tf2.Path); - } + workbook.SaveAs(tf2.Path); } /// @@ -293,16 +277,14 @@ public void CanLoadFromTemplate() [Test] public void CanOpenWorksheetWithEscapedApostrophe() { - string title = ""; - TestDelegate openWorkbook = () => + var title = ""; + void openWorkbook() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EscapedApostrophe.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); - title = ws.Name; - } - }; + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EscapedApostrophe.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); + title = ws.Name; + } Assert.DoesNotThrow(openWorkbook); Assert.AreEqual("L'E", title); @@ -311,26 +293,20 @@ public void CanOpenWorksheetWithEscapedApostrophe() [Test] public void CanRoundTripSheetProtectionForObjects() { - using (var book = new XLWorkbook()) - { - var sheet = book.AddWorksheet("TestSheet"); - sheet.Protect() - .AllowElement(XLSheetProtectionElements.EditObjects | XLSheetProtectionElements.EditScenarios); + using var book = new XLWorkbook(); + var sheet = book.AddWorksheet("TestSheet"); + sheet.Protect() + .AllowElement(XLSheetProtectionElements.EditObjects | XLSheetProtectionElements.EditScenarios); - Assert.AreEqual(XLSheetProtectionElements.SelectEverything | XLSheetProtectionElements.EditObjects | XLSheetProtectionElements.EditScenarios, sheet.Protection.AllowedElements); + Assert.AreEqual(XLSheetProtectionElements.SelectEverything | XLSheetProtectionElements.EditObjects | XLSheetProtectionElements.EditScenarios, sheet.Protection.AllowedElements); - using (var xlStream = new MemoryStream()) - { - book.SaveAs(xlStream); + using var xlStream = new MemoryStream(); + book.SaveAs(xlStream); - using (var persistedBook = new XLWorkbook(xlStream)) - { - var persistedSheet = persistedBook.Worksheets.Worksheet(1); + using var persistedBook = new XLWorkbook(xlStream); + var persistedSheet = persistedBook.Worksheets.Worksheet(1); - Assert.AreEqual(sheet.Protection.AllowedElements, persistedSheet.Protection.AllowedElements); - } - } - } + Assert.AreEqual(sheet.Protection.AllowedElements, persistedSheet.Protection.AllowedElements); } [Test] @@ -343,146 +319,145 @@ public void CanRoundTripSheetProtectionForObjects() [TestCase("DATE(2018,1,28)", 43128)] public void LoadFormulaCachedValue(string formula, object expectedCachedValue) { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var book1 = new XLWorkbook()) { - using (XLWorkbook book1 = new XLWorkbook()) - { - var sheet = book1.AddWorksheet("sheet1"); - sheet.Cell("A1").Value = 123; - sheet.Cell("A2").FormulaA1 = formula; - var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; - - book1.SaveAs(ms, options); - } - ms.Position = 0; + var sheet = book1.AddWorksheet("sheet1"); + sheet.Cell("A1").Value = 123; + sheet.Cell("A2").FormulaA1 = formula; + var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; - using (XLWorkbook book2 = new XLWorkbook(ms)) - { - var ws = book2.Worksheet(1); - Assert.IsFalse(ws.Cell("A2").NeedsRecalculation); - Assert.AreEqual(expectedCachedValue, ws.Cell("A2").CachedValue); - } + book1.SaveAs(ms, options); } + ms.Position = 0; + + using var book2 = new XLWorkbook(ms); + var ws = book2.Worksheet(1); + Assert.IsFalse(ws.Cell("A2").NeedsRecalculation); + Assert.AreEqual(expectedCachedValue, ws.Cell("A2").CachedValue); } [Test] public void LoadingOptions() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\ExternalLinks\WorkbookWithExternalLink.xlsx"))) - { - Assert.DoesNotThrow(() => new XLWorkbook(stream, new LoadOptions { RecalculateAllFormulas = false })); - Assert.Throws(() => new XLWorkbook(stream, new LoadOptions { RecalculateAllFormulas = true })); - - Assert.AreEqual(XLEventTracking.Disabled, new XLWorkbook(stream, new LoadOptions { EventTracking = XLEventTracking.Disabled }).EventTracking); - Assert.AreEqual(XLEventTracking.Enabled, new XLWorkbook(stream, new LoadOptions { EventTracking = XLEventTracking.Enabled }).EventTracking); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\ExternalLinks\WorkbookWithExternalLink.xlsx")); + Assert.DoesNotThrow(() => new XLWorkbook(stream, new LoadOptions { RecalculateAllFormulas = false })); + Assert.Throws(() => new XLWorkbook(stream, new LoadOptions { RecalculateAllFormulas = true })); + + using var xLWorkbookExpectedDisabled = new XLWorkbook(stream, new LoadOptions { EventTracking = XLEventTracking.Disabled }); + Assert.AreEqual(XLEventTracking.Disabled, xLWorkbookExpectedDisabled.EventTracking); + using var xLWorkbookExpectedEnabled = new XLWorkbook(stream, new LoadOptions { EventTracking = XLEventTracking.Enabled }); + Assert.AreEqual(XLEventTracking.Enabled, xLWorkbookExpectedEnabled.EventTracking); } [Test] public void CanLoadWorksheetStyle() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\BaseColumnWidth.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\BaseColumnWidth.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); + + Assert.AreEqual(8, ws.Style.Font.FontSize); + Assert.AreEqual("Arial", ws.Style.Font.FontName); + Assert.AreEqual(8, ws.Cell("A1").Style.Font.FontSize); + Assert.AreEqual("Arial", ws.Cell("A1").Style.Font.FontName); + } - Assert.AreEqual(8, ws.Style.Font.FontSize); - Assert.AreEqual("Arial", ws.Style.Font.FontName); - Assert.AreEqual(8, ws.Cell("A1").Style.Font.FontSize); - Assert.AreEqual("Arial", ws.Cell("A1").Style.Font.FontName); - } + [Test] + public void CanLoadNullText() + { + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\TextNull.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); + Assert.Multiple(() => + { + Assert.That(ws.Cell("C9").Value, Is.EqualTo("")); + Assert.That(ws.Cell("A1").Value, Is.EqualTo("姓名")); + Assert.That(ws.Cell("B1").Value, Is.EqualTo("年龄")); + Assert.That(ws.Cell("C11").Value, Is.EqualTo("服务")); + }); } [Test] public void CanCorrectLoadWorkbookCellWithStringDataType() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CellWithStringDataType.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var cellToCheck = wb.Worksheet(1).Cell("B2"); - Assert.AreEqual(XLDataType.Text, cellToCheck.DataType); - Assert.AreEqual("String with String Data type", cellToCheck.Value); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\CellWithStringDataType.xlsx")); + using var wb = new XLWorkbook(stream); + var cellToCheck = wb.Worksheet(1).Cell("B2"); + Assert.AreEqual(XLDataType.Text, cellToCheck.DataType); + Assert.AreEqual("String with String Data type", cellToCheck.Value); } [Test] public void CanLoadFileWithInvalidSelectedRanges() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\SelectedRanges\InvalidSelectedRange.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\SelectedRanges\InvalidSelectedRange.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); - Assert.AreEqual(2, ws.SelectedRanges.Count); - Assert.AreEqual("B2:B2", ws.SelectedRanges.First().RangeAddress.ToString()); - Assert.AreEqual("B2:C2", ws.SelectedRanges.Last().RangeAddress.ToString()); - } + Assert.AreEqual(2, ws.SelectedRanges.Count); + Assert.AreEqual("B2:B2", ws.SelectedRanges.First().RangeAddress.ToString()); + Assert.AreEqual("B2:C2", ws.SelectedRanges.Last().RangeAddress.ToString()); } [Test] public void CanLoadCellsWithoutReferencesCorrectly() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LO\xlsx\row-index-1-based.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\LO\xlsx\row-index-1-based.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); - Assert.AreEqual("Page 1", ws.Name); + Assert.AreEqual("Page 1", ws.Name); - var expected = new Dictionary() - { - ["A1"] = "Action Plan.Name", - ["B1"] = "Action Plan.Description", - ["A2"] = "Jerry", - ["B2"] = "This is a longer Text.\nSecond line.\nThird line.", - ["A3"] = "", - ["B3"] = "" - }; + var expected = new Dictionary + { + ["A1"] = "Action Plan.Name", + ["B1"] = "Action Plan.Description", + ["A2"] = "Jerry", + ["B2"] = "This is a longer Text.\nSecond line.\nThird line.", + ["A3"] = "", + ["B3"] = "" + }; - foreach (var pair in expected) - Assert.AreEqual(pair.Value, ws.Cell(pair.Key).GetString(), pair.Key); + foreach (var pair in expected) + { + Assert.AreEqual(pair.Value, ws.Cell(pair.Key).GetString(), pair.Key); } } [Test] public void CorrectlyLoadMergedCellsBorder() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\MergedCellsBorder\inputfile.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); - - var c = ws.Cell("B2"); - Assert.AreEqual(XLColorType.Theme, c.Style.Border.TopBorderColor.ColorType); - Assert.AreEqual(XLThemeColor.Accent1, c.Style.Border.TopBorderColor.ThemeColor); - Assert.AreEqual(0.39994506668294322d, c.Style.Border.TopBorderColor.ThemeTint, XLHelper.Epsilon); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\MergedCellsBorder\inputfile.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); + + var c = ws.Cell("B2"); + Assert.AreEqual(XLColorType.Theme, c.Style.Border.TopBorderColor.ColorType); + Assert.AreEqual(XLThemeColor.Accent1, c.Style.Border.TopBorderColor.ThemeColor); + Assert.AreEqual(0.39994506668294322d, c.Style.Border.TopBorderColor.ThemeTint, XLHelper.Epsilon); } [Test] public void CorrectlyLoadDefaultRowAndColumnStyles() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\RowAndColumnStyles\inputfile.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\RowAndColumnStyles\inputfile.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); - Assert.AreEqual(8, ws.Row(1).Style.Font.FontSize); - Assert.AreEqual(8, ws.Row(2).Style.Font.FontSize); - Assert.AreEqual(8, ws.Column("A").Style.Font.FontSize); - } + Assert.AreEqual(8, ws.Row(1).Style.Font.FontSize); + Assert.AreEqual(8, ws.Row(2).Style.Font.FontSize); + Assert.AreEqual(8, ws.Column("A").Style.Font.FontSize); } [Test] public void EmptyNumberFormatIdTreatedAsGeneral() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyNumberFormatId.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet(1); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyNumberFormatId.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); - Assert.AreEqual(XLPredefinedFormat.General, ws.Cell("A2").Style.NumberFormat.NumberFormatId); - } + Assert.AreEqual(XLPredefinedFormat.General, ws.Cell("A2").Style.NumberFormat.NumberFormatId); } [Test] @@ -501,46 +476,44 @@ public void CanLoadProperties() const string company = "TestCompany"; const string manager = "TestManager"; - using (var stream = new MemoryStream()) + using var stream = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var sheet = wb.AddWorksheet("sheet1"); - - wb.Properties.Author = author; - wb.Properties.Title = title; - wb.Properties.Subject = subject; - wb.Properties.Category = category; - wb.Properties.Keywords = keywords; - wb.Properties.Comments = comments; - wb.Properties.Status = status; - wb.Properties.Created = created; - wb.Properties.Modified = modified; - wb.Properties.LastModifiedBy = lastModifiedBy; - wb.Properties.Company = company; - wb.Properties.Manager = manager; - - wb.SaveAs(stream, true); - } - - stream.Position = 0; - - using (var wb = new XLWorkbook(stream)) - { - Assert.AreEqual(author, wb.Properties.Author); - Assert.AreEqual(title, wb.Properties.Title); - Assert.AreEqual(subject, wb.Properties.Subject); - Assert.AreEqual(category, wb.Properties.Category); - Assert.AreEqual(keywords, wb.Properties.Keywords); - Assert.AreEqual(comments, wb.Properties.Comments); - Assert.AreEqual(status, wb.Properties.Status); - Assert.AreEqual(created, wb.Properties.Created); - Assert.AreEqual(modified, wb.Properties.Modified); - Assert.AreEqual(lastModifiedBy, wb.Properties.LastModifiedBy); - Assert.AreEqual(company, wb.Properties.Company); - Assert.AreEqual(manager, wb.Properties.Manager); - } + wb.AddWorksheet("sheet1"); + + wb.Properties.Author = author; + wb.Properties.Title = title; + wb.Properties.Subject = subject; + wb.Properties.Category = category; + wb.Properties.Keywords = keywords; + wb.Properties.Comments = comments; + wb.Properties.Status = status; + wb.Properties.Created = created; + wb.Properties.Modified = modified; + wb.Properties.LastModifiedBy = lastModifiedBy; + wb.Properties.Company = company; + wb.Properties.Manager = manager; + + wb.SaveAs(stream, true); + } + + stream.Position = 0; + + using (var wb = new XLWorkbook(stream)) + { + Assert.AreEqual(author, wb.Properties.Author); + Assert.AreEqual(title, wb.Properties.Title); + Assert.AreEqual(subject, wb.Properties.Subject); + Assert.AreEqual(category, wb.Properties.Category); + Assert.AreEqual(keywords, wb.Properties.Keywords); + Assert.AreEqual(comments, wb.Properties.Comments); + Assert.AreEqual(status, wb.Properties.Status); + Assert.AreEqual(created, wb.Properties.Created); + Assert.AreEqual(modified, wb.Properties.Modified); + Assert.AreEqual(lastModifiedBy, wb.Properties.LastModifiedBy); + Assert.AreEqual(company, wb.Properties.Company); + Assert.AreEqual(manager, wb.Properties.Manager); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/CopyContentsTests.cs b/ClosedXML.Tests/Excel/Misc/CopyContentsTests.cs index 458e19480..74872af15 100644 --- a/ClosedXML.Tests/Excel/Misc/CopyContentsTests.cs +++ b/ClosedXML.Tests/Excel/Misc/CopyContentsTests.cs @@ -11,14 +11,14 @@ private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNu int destRowNumber) { { - IXLRow destinationRow = destSheet.Row(destRowNumber); + var destinationRow = destSheet.Row(destRowNumber); destinationRow.Clear(); - IXLRow originalRow = originalSheet.Row(originalRowNumber); - int columnNumber = originalRow.LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; + var originalRow = originalSheet.Row(originalRowNumber); + var columnNumber = originalRow.LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; - IXLRange originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber); - IXLRange destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber); + var originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber); + var destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber); originalRange.CopyTo(destRange); } } @@ -26,8 +26,8 @@ private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNu [Test] public void CopyConditionalFormatsCount() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue); ws.Cell("A2").Value = ws.FirstCell(); Assert.AreEqual(2, ws.ConditionalFormats.Count()); @@ -36,8 +36,8 @@ public void CopyConditionalFormatsCount() [Test] public void CopyConditionalFormatsFixedNum() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "1"; ws.Cell("B1").Value = "1"; ws.Cell("A1").AddConditionalFormat().WhenEquals(1).Fill.SetBackgroundColor(XLColor.Blue); @@ -49,8 +49,8 @@ public void CopyConditionalFormatsFixedNum() [Test] public void CopyConditionalFormatsFixedString() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "A"; ws.Cell("B1").Value = "B"; ws.Cell("A1").AddConditionalFormat().WhenEquals("A").Fill.SetBackgroundColor(XLColor.Blue); @@ -62,8 +62,8 @@ public void CopyConditionalFormatsFixedString() [Test] public void CopyConditionalFormatsFixedStringNum() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "1"; ws.Cell("B1").Value = "1"; ws.Cell("A1").AddConditionalFormat().WhenEquals("1").Fill.SetBackgroundColor(XLColor.Blue); @@ -75,8 +75,8 @@ public void CopyConditionalFormatsFixedStringNum() [Test] public void CopyConditionalFormatsRelative() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Cell("A1").Value = "1"; ws.Cell("B1").Value = "1"; ws.Cell("A1").AddConditionalFormat().WhenEquals("=B1").Fill.SetBackgroundColor(XLColor.Blue); @@ -88,25 +88,25 @@ public void CopyConditionalFormatsRelative() [Test] public void TestRowCopyContents() { - var workbook = new XLWorkbook(); - IXLWorksheet originalSheet = workbook.Worksheets.Add("original"); - IXLWorksheet copyRowSheet = workbook.Worksheets.Add("copy row"); - IXLWorksheet copyRowAsRangeSheet = workbook.Worksheets.Add("copy row as range"); - IXLWorksheet copyRangeSheet = workbook.Worksheets.Add("copy range"); + using var workbook = new XLWorkbook(); + var originalSheet = workbook.Worksheets.Add("original"); + var copyRowSheet = workbook.Worksheets.Add("copy row"); + var copyRowAsRangeSheet = workbook.Worksheets.Add("copy row as range"); + var copyRangeSheet = workbook.Worksheets.Add("copy range"); originalSheet.Cell("A2").SetValue("test value"); originalSheet.Range("A2:E2").Merge(); { - IXLRange originalRange = originalSheet.Range("A2:E2"); - IXLRange destinationRange = copyRangeSheet.Range("A2:E2"); + var originalRange = originalSheet.Range("A2:E2"); + var destinationRange = copyRangeSheet.Range("A2:E2"); originalRange.CopyTo(destinationRange); } CopyRowAsRange(originalSheet, 2, copyRowAsRangeSheet, 3); { - IXLRow originalRow = originalSheet.Row(2); - IXLRow destinationRow = copyRowSheet.Row(2); + var originalRow = originalSheet.Row(2); + var destinationRow = copyRowSheet.Row(2); copyRowSheet.Cell("G2").Value = "must be removed after copy"; originalRow.CopyTo(destinationRow); } @@ -116,16 +116,14 @@ public void TestRowCopyContents() [Test] public void UpdateCellsWorksheetTest() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet1"); - ws1.Cell(1, 1).Value = "hello, world."; + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet1"); + ws1.Cell(1, 1).Value = "hello, world."; - var ws2 = ws1.CopyTo("Sheet2"); + var ws2 = ws1.CopyTo("Sheet2"); - Assert.AreEqual("Sheet1", ws1.FirstCell().Address.Worksheet.Name); - Assert.AreEqual("Sheet2", ws2.FirstCell().Address.Worksheet.Name); - } + Assert.AreEqual("Sheet1", ws1.FirstCell().Address.Worksheet.Name); + Assert.AreEqual("Sheet2", ws2.FirstCell().Address.Worksheet.Name); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/ExtensionsTests.cs b/ClosedXML.Tests/Excel/Misc/ExtensionsTests.cs index 56df75c47..46d65a766 100644 --- a/ClosedXML.Tests/Excel/Misc/ExtensionsTests.cs +++ b/ClosedXML.Tests/Excel/Misc/ExtensionsTests.cs @@ -3,7 +3,7 @@ using NUnit.Framework; using System; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Misc { [TestFixture] public class ExtensionsTests @@ -11,23 +11,23 @@ public class ExtensionsTests [Test] public void FixNewLines() { - Assert.AreEqual("\n".FixNewLines(), Environment.NewLine); - Assert.AreEqual("\r\n".FixNewLines(), Environment.NewLine); - Assert.AreEqual("\rS\n".FixNewLines(), "\rS" + Environment.NewLine); - Assert.AreEqual("\r\n\n".FixNewLines(), Environment.NewLine + Environment.NewLine); + Assert.AreEqual("\n".FixNewLines(), XLConstants.NewLine); + Assert.AreEqual("\r\n".FixNewLines(), XLConstants.NewLine); + Assert.AreEqual("\rS\n".FixNewLines(), "\rS" + XLConstants.NewLine); + Assert.AreEqual("\r\n\n".FixNewLines(), XLConstants.NewLine + XLConstants.NewLine); } [Test] public void DoubleSaveRound() { - Double value = 1234.1234567; + var value = 1234.1234567; Assert.AreEqual(value.SaveRound(), Math.Round(value, 6)); } [Test] public void DoubleValueSaveRound() { - Double value = 1234.1234567; + var value = 1234.1234567; Assert.AreEqual(new DoubleValue(value).SaveRound().Value, Math.Round(value, 6)); } @@ -70,7 +70,7 @@ public void DoubleValueSaveRound() [TestCase(null, ExpectedResult = null)] public string CanEscapeSheetName(string sheetName) { - return StringExtensions.EscapeSheetName(sheetName); + return sheetName.EscapeSheetName(); } [TestCase("TestSheet", ExpectedResult = "TestSheet")] @@ -78,7 +78,7 @@ public string CanEscapeSheetName(string sheetName) [TestCase("'O''Kelly'", ExpectedResult = "O'Kelly")] public string CanUnescapeSheetName(string sheetName) { - return StringExtensions.UnescapeSheetName(sheetName); + return sheetName.UnescapeSheetName(); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/FormulaTests.cs b/ClosedXML.Tests/Excel/Misc/FormulaTests.cs index f9410ff7a..a173ba457 100644 --- a/ClosedXML.Tests/Excel/Misc/FormulaTests.cs +++ b/ClosedXML.Tests/Excel/Misc/FormulaTests.cs @@ -4,7 +4,7 @@ using System; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Misc { [TestFixture] public class FormulaTests @@ -12,8 +12,8 @@ public class FormulaTests [Test] public void CopyFormula() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").FormulaA1 = "B1"; ws.Cell("A1").CopyTo("A2"); Assert.AreEqual("B2", ws.Cell("A2").FormulaA1); @@ -22,140 +22,126 @@ public void CopyFormula() [Test] public void CopyFormula2() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - - ws.Cell("A1").FormulaA1 = "A2-1"; - ws.Cell("A1").CopyTo("B1"); - Assert.AreEqual("R[1]C-1", ws.Cell("A1").FormulaR1C1); - Assert.AreEqual("R[1]C-1", ws.Cell("B1").FormulaR1C1); - Assert.AreEqual("B2-1", ws.Cell("B1").FormulaA1); - - ws.Cell("A1").FormulaA1 = "B1+1"; - ws.Cell("A1").CopyTo("A2"); - Assert.AreEqual("RC[1]+1", ws.Cell("A1").FormulaR1C1); - Assert.AreEqual("RC[1]+1", ws.Cell("A2").FormulaR1C1); - Assert.AreEqual("B2+1", ws.Cell("A2").FormulaA1); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Cell("A1").FormulaA1 = "A2-1"; + ws.Cell("A1").CopyTo("B1"); + Assert.AreEqual("R[1]C-1", ws.Cell("A1").FormulaR1C1); + Assert.AreEqual("R[1]C-1", ws.Cell("B1").FormulaR1C1); + Assert.AreEqual("B2-1", ws.Cell("B1").FormulaA1); + + ws.Cell("A1").FormulaA1 = "B1+1"; + ws.Cell("A1").CopyTo("A2"); + Assert.AreEqual("RC[1]+1", ws.Cell("A1").FormulaR1C1); + Assert.AreEqual("RC[1]+1", ws.Cell("A2").FormulaR1C1); + Assert.AreEqual("B2+1", ws.Cell("A2").FormulaA1); } [Test] public void CopyFormulaWithSheetNameThatResemblesFormula() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.Worksheets.Add("S10 Data"); - ws.Cell("A1").Value = "Some value"; - ws.Cell("A2").Value = 123; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("S10 Data"); + ws.Cell("A1").Value = "Some value"; + ws.Cell("A2").Value = 123; - ws = wb.Worksheets.Add("Summary"); - ws.Cell("A1").FormulaA1 = "='S10 Data'!A1"; - Assert.AreEqual("Some value", ws.Cell("A1").Value); + ws = wb.Worksheets.Add("Summary"); + ws.Cell("A1").FormulaA1 = "='S10 Data'!A1"; + Assert.AreEqual("Some value", ws.Cell("A1").Value); - ws.Cell("A1").CopyTo("A2"); - Assert.AreEqual("'S10 Data'!A2", ws.Cell("A2").FormulaA1); + ws.Cell("A1").CopyTo("A2"); + Assert.AreEqual("'S10 Data'!A2", ws.Cell("A2").FormulaA1); - ws.Cell("A1").CopyTo("B1"); - Assert.AreEqual("'S10 Data'!B1", ws.Cell("B1").FormulaA1); + ws.Cell("A1").CopyTo("B1"); + Assert.AreEqual("'S10 Data'!B1", ws.Cell("B1").FormulaA1); - ws.Cell("A3").FormulaA1 = "=SUM('S10 Data'!A2)"; - Assert.AreEqual(123, ws.Cell("A3").Value); - } + ws.Cell("A3").FormulaA1 = "=SUM('S10 Data'!A2)"; + Assert.AreEqual(123, ws.Cell("A3").Value); } [Test] public void FormulaWithReferenceIncludingSheetName() { - using (var wb = new XLWorkbook()) - { - object value; - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").InsertData(Enumerable.Range(1, 50)); - ws.Cell("B1").FormulaA1 = "=SUM(A1:A50)"; - value = ws.Cell("B1").Value; - Assert.AreEqual(1275, value); - - ws = wb.AddWorksheet("Sheet2"); - - ws.Cell("A1").FormulaA1 = "=SUM(Sheet1!A1:Sheet1!A50)"; - value = ws.Cell("A1").Value; - Assert.AreEqual(1275, value); - - ws.Cell("B1").FormulaA1 = "=SUM(Sheet1!A1:A50)"; - value = ws.Cell("B1").Value; - Assert.AreEqual(1275, value); - } + using var wb = new XLWorkbook(); + object value; + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").InsertData(Enumerable.Range(1, 50)); + ws.Cell("B1").FormulaA1 = "=SUM(A1:A50)"; + value = ws.Cell("B1").Value; + Assert.AreEqual(1275, value); + + ws = wb.AddWorksheet("Sheet2"); + + ws.Cell("A1").FormulaA1 = "=SUM(Sheet1!A1:Sheet1!A50)"; + value = ws.Cell("A1").Value; + Assert.AreEqual(1275, value); + + ws.Cell("B1").FormulaA1 = "=SUM(Sheet1!A1:A50)"; + value = ws.Cell("B1").Value; + Assert.AreEqual(1275, value); } [Test] public void InvalidReferences() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").InsertData(Enumerable.Range(1, 50)); - ws = wb.AddWorksheet("Sheet2"); - - ws.Cell("A1").FormulaA1 = "=SUM(Sheet1!A1:Sheet2!A50)"; - Assert.That(() => ws.Cell("A1").Value, Throws.InstanceOf()); - - ws.Cell("B1").FormulaA1 = "=SUM(Sheet1!A1:UnknownSheet!A50)"; - Assert.That(() => ws.Cell("B1").Value, Throws.InstanceOf()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").InsertData(Enumerable.Range(1, 50)); + ws = wb.AddWorksheet("Sheet2"); + + ws.Cell("A1").FormulaA1 = "=SUM(Sheet1!A1:Sheet2!A50)"; + Assert.That(() => ws.Cell("A1").Value, Throws.InstanceOf()); + + ws.Cell("B1").FormulaA1 = "=SUM(Sheet1!A1:UnknownSheet!A50)"; + Assert.That(() => ws.Cell("B1").Value, Throws.InstanceOf()); } [Test] public void DateAgainstStringComparison() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = new DateTime(2016, 1, 1); - ws.Cell("A1").DataType = XLDataType.DateTime; - - ws.Cell("A2").FormulaA1 = @"=IF(A1 = """", ""A"", ""B"")"; - var actual = ws.Cell("A2").Value; - Assert.AreEqual(actual, "B"); - - ws.Cell("A3").FormulaA1 = @"=IF("""" = A1, ""A"", ""B"")"; - actual = ws.Cell("A3").Value; - Assert.AreEqual(actual, "B"); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = new DateTime(2016, 1, 1); + ws.Cell("A1").DataType = XLDataType.DateTime; + + ws.Cell("A2").FormulaA1 = @"=IF(A1 = """", ""A"", ""B"")"; + var actual = ws.Cell("A2").Value; + Assert.AreEqual(actual, "B"); + + ws.Cell("A3").FormulaA1 = @"=IF("""" = A1, ""A"", ""B"")"; + actual = ws.Cell("A3").Value; + Assert.AreEqual(actual, "B"); } [Test] public void FormulaThatReferencesEntireRow() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = 1; - ws.FirstCell().CellRight().Value = 2; - ws.FirstCell().CellRight(5).Value = 3; - - ws.FirstCell().CellBelow().FormulaA1 = "=SUM(1:1)"; - - var actual = ws.FirstCell().CellBelow().Value; - Assert.AreEqual(6, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().Value = 1; + ws.FirstCell().CellRight().Value = 2; + ws.FirstCell().CellRight(5).Value = 3; + + ws.FirstCell().CellBelow().FormulaA1 = "=SUM(1:1)"; + + var actual = ws.FirstCell().CellBelow().Value; + Assert.AreEqual(6, actual); } [Test] public void FormulaThatReferencesEntireColumn() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = 1; - ws.FirstCell().CellBelow().Value = 2; - ws.FirstCell().CellBelow(5).Value = 3; - - ws.FirstCell().CellRight().FormulaA1 = "=SUM(A:A)"; - - var actual = ws.FirstCell().CellRight().Value; - Assert.AreEqual(6, actual); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().Value = 1; + ws.FirstCell().CellBelow().Value = 2; + ws.FirstCell().CellBelow(5).Value = 3; + + ws.FirstCell().CellRight().FormulaA1 = "=SUM(A:A)"; + + var actual = ws.FirstCell().CellRight().Value; + Assert.AreEqual(6, actual); } [Test] @@ -190,39 +176,35 @@ public void FormulasWithErrors() [Test] public void UnicodeLetterParsing() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet C C"); - var ws2 = wb.AddWorksheet("C"); - var ws3 = wb.AddWorksheet("Sheet3"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet C C"); + var ws2 = wb.AddWorksheet("C"); + var ws3 = wb.AddWorksheet("Sheet3"); - ws1.FirstCell().SetValue(100); - ws2.FirstCell().SetValue(50); + ws1.FirstCell().SetValue(100); + ws2.FirstCell().SetValue(50); - ws3.FirstCell().FormulaA1 = "='Sheet C C'!A1"; - ws3.FirstCell().CellBelow().FormulaA1 = "C!A1"; + ws3.FirstCell().FormulaA1 = "='Sheet C C'!A1"; + ws3.FirstCell().CellBelow().FormulaA1 = "C!A1"; - Assert.AreEqual(100, ws3.FirstCell().Value); - Assert.AreEqual(50, ws3.FirstCell().CellBelow().Value); - } + Assert.AreEqual(100, ws3.FirstCell().Value); + Assert.AreEqual(50, ws3.FirstCell().CellBelow().Value); } [Test] public void ShiftFormula() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - ws.Cell("B1").FormulaA1 = "ATAN2(C1,C2)"; - ws.Cell("B2").FormulaA1 = "DEC2HEX(C2)"; - ws.Range("B3:B5").FormulaA1 = "{DAYS360(C3:C5, D3:D5)}"; - - ws.Column(1).Delete(); - - Assert.AreEqual("ATAN2(B1,B2)", ws.Cell("A1").FormulaA1); - Assert.AreEqual("DEC2HEX(B2)", ws.Cell("A2").FormulaA1); - Assert.AreEqual("{DAYS360(B3:B5, C3:C5)}", ws.Cell("A3").FormulaA1); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + ws.Cell("B1").FormulaA1 = "ATAN2(C1,C2)"; + ws.Cell("B2").FormulaA1 = "DEC2HEX(C2)"; + ws.Range("B3:B5").FormulaA1 = "{DAYS360(C3:C5, D3:D5)}"; + + ws.Column(1).Delete(); + + Assert.AreEqual("ATAN2(B1,B2)", ws.Cell("A1").FormulaA1); + Assert.AreEqual("DEC2HEX(B2)", ws.Cell("A2").FormulaA1); + Assert.AreEqual("{DAYS360(B3:B5, C3:C5)}", ws.Cell("A3").FormulaA1); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/HyperlinkTests.cs b/ClosedXML.Tests/Excel/Misc/HyperlinkTests.cs index 0674e0edb..3e7d675a7 100644 --- a/ClosedXML.Tests/Excel/Misc/HyperlinkTests.cs +++ b/ClosedXML.Tests/Excel/Misc/HyperlinkTests.cs @@ -9,24 +9,22 @@ public class HyperlinkTests [Test] public void TestHyperlinks() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet1"); - var ws2 = wb.Worksheets.Add("Sheet2"); + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet1"); + var ws2 = wb.Worksheets.Add("Sheet2"); - var targetCell = ws2.Cell("A1"); - var targetRange = ws2.Range("A1", "B1"); + var targetCell = ws2.Cell("A1"); + var targetRange = ws2.Range("A1", "B1"); - var linkCell1 = ws1.Cell("A1"); - linkCell1.Value = "Link to IXLCell"; - linkCell1.SetHyperlink(new XLHyperlink(targetCell)); - Assert.AreEqual("Sheet2!A1", linkCell1.GetHyperlink().InternalAddress); + var linkCell1 = ws1.Cell("A1"); + linkCell1.Value = "Link to IXLCell"; + linkCell1.SetHyperlink(new XLHyperlink(targetCell)); + Assert.AreEqual("Sheet2!A1", linkCell1.GetHyperlink().InternalAddress); - var linkRange1 = ws1.Cell("A2"); - linkRange1.Value = "Link to IXLRangeBase"; - linkRange1.SetHyperlink(new XLHyperlink(targetRange)); - Assert.AreEqual("Sheet2!A1:B1", linkRange1.GetHyperlink().InternalAddress); - } + var linkRange1 = ws1.Cell("A2"); + linkRange1.Value = "Link to IXLRangeBase"; + linkRange1.SetHyperlink(new XLHyperlink(targetRange)); + Assert.AreEqual("Sheet2!A1:B1", linkRange1.GetHyperlink().InternalAddress); } } } diff --git a/ClosedXML.Tests/Excel/Misc/SearchTests.cs b/ClosedXML.Tests/Excel/Misc/SearchTests.cs index 661efdde0..a824c6620 100644 --- a/ClosedXML.Tests/Excel/Misc/SearchTests.cs +++ b/ClosedXML.Tests/Excel/Misc/SearchTests.cs @@ -11,68 +11,64 @@ public class SearchTests [Test] public void TestSearch() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\CellValues.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\CellValues.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); - IXLCells foundCells; + IXLCells foundCells; - foundCells = ws.Search("Initial Value"); - Assert.AreEqual(1, foundCells.Count()); - Assert.AreEqual("B2", foundCells.Single().Address.ToString()); - Assert.AreEqual("Initial Value", foundCells.Single().GetString()); + foundCells = ws.Search("Initial Value"); + Assert.AreEqual(1, foundCells.Count()); + Assert.AreEqual("B2", foundCells.Single().Address.ToString()); + Assert.AreEqual("Initial Value", foundCells.Single().GetString()); - foundCells = ws.Search("Using"); - Assert.AreEqual(2, foundCells.Count()); - Assert.AreEqual("D2", foundCells.First().Address.ToString()); - Assert.AreEqual("Using Get...()", foundCells.First().GetString()); - Assert.AreEqual(2, foundCells.Count()); - Assert.AreEqual("E2", foundCells.Last().Address.ToString()); - Assert.AreEqual("Using GetValue()", foundCells.Last().GetString()); + foundCells = ws.Search("Using"); + Assert.AreEqual(2, foundCells.Count()); + Assert.AreEqual("D2", foundCells.First().Address.ToString()); + Assert.AreEqual("Using Get...()", foundCells.First().GetString()); + Assert.AreEqual(2, foundCells.Count()); + Assert.AreEqual("E2", foundCells.Last().Address.ToString()); + Assert.AreEqual("Using GetValue()", foundCells.Last().GetString()); - foundCells = ws.Search("1234"); - Assert.AreEqual(4, foundCells.Count()); - Assert.AreEqual("C5,D5,E5,F5", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); + foundCells = ws.Search("1234"); + Assert.AreEqual(4, foundCells.Count()); + Assert.AreEqual("C5,D5,E5,F5", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); - foundCells = ws.Search("Sep"); - Assert.AreEqual(2, foundCells.Count()); - Assert.AreEqual("B3,G3", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); + foundCells = ws.Search("Sep"); + Assert.AreEqual(2, foundCells.Count()); + Assert.AreEqual("B3,G3", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); - foundCells = ws.Search("1234", CompareOptions.Ordinal, true); - Assert.AreEqual(5, foundCells.Count()); - Assert.AreEqual("B5,C5,D5,E5,F5", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); + foundCells = ws.Search("1234", CompareOptions.Ordinal, true); + Assert.AreEqual(5, foundCells.Count()); + Assert.AreEqual("B5,C5,D5,E5,F5", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); - foundCells = ws.Search("test case", CompareOptions.Ordinal); - Assert.AreEqual(0, foundCells.Count()); + foundCells = ws.Search("test case", CompareOptions.Ordinal); + Assert.AreEqual(0, foundCells.Count()); - foundCells = ws.Search("test case", CompareOptions.OrdinalIgnoreCase); - Assert.AreEqual(6, foundCells.Count()); - } + foundCells = ws.Search("test case", CompareOptions.OrdinalIgnoreCase); + Assert.AreEqual(6, foundCells.Count()); } [Test] public void TestSearch2() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\Formulas.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheets.First(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\Formulas.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheets.First(); - IXLCells foundCells; + IXLCells foundCells; - foundCells = ws.Search("3", CompareOptions.Ordinal); - Assert.AreEqual(10, foundCells.Count()); - Assert.AreEqual("C2", foundCells.First().Address.ToString()); + foundCells = ws.Search("3", CompareOptions.Ordinal); + Assert.AreEqual(10, foundCells.Count()); + Assert.AreEqual("C2", foundCells.First().Address.ToString()); - foundCells = ws.Search("A2", CompareOptions.Ordinal, true); - Assert.AreEqual(6, foundCells.Count()); - Assert.AreEqual("C2,D2,B6,C6,D6,A11", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); + foundCells = ws.Search("A2", CompareOptions.Ordinal, true); + Assert.AreEqual(6, foundCells.Count()); + Assert.AreEqual("C2,D2,B6,C6,D6,A11", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); - foundCells = ws.Search("RC", CompareOptions.Ordinal, true); - Assert.AreEqual(3, foundCells.Count()); - Assert.AreEqual("E2,E3,E4", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); - } + foundCells = ws.Search("RC", CompareOptions.Ordinal, true); + Assert.AreEqual(3, foundCells.Count()); + Assert.AreEqual("E2,E3,E4", string.Join(",", foundCells.Select(c => c.Address.ToString()).ToArray())); } } } diff --git a/ClosedXML.Tests/Excel/Misc/StylesTests.cs b/ClosedXML.Tests/Excel/Misc/StylesTests.cs index 8a74441e6..13636cc2b 100644 --- a/ClosedXML.Tests/Excel/Misc/StylesTests.cs +++ b/ClosedXML.Tests/Excel/Misc/StylesTests.cs @@ -28,16 +28,16 @@ private static void SetupBorders(IXLRange range) [Test] public void InsideBorderTest() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - IXLRange range = ws.Range("B2:D4"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var range = ws.Range("B2:D4"); SetupBorders(range); range.Style.Border.InsideBorder = XLBorderStyleValues.Thin; range.Style.Border.InsideBorderColor = XLColor.Red; - IXLCell center = range.Cell(2, 2); + var center = range.Cell(2, 2); Assert.AreEqual(XLColor.Red, center.Style.Border.TopBorderColor); Assert.AreEqual(XLColor.Red, center.Style.Border.BottomBorderColor); @@ -64,21 +64,20 @@ public void InsideBorderTest() [Test] public void ResolveThemeColors() { - using (var wb = new XLWorkbook()) - { - string color; - color = wb.Theme.ResolveThemeColor(XLThemeColor.Accent1).Color.ToHex(); - Assert.AreEqual("FF4F81BD", color); + using var wb = new XLWorkbook(); + string color; + color = wb.Theme.ResolveThemeColor(XLThemeColor.Accent1).Color.ToHex(); + Assert.AreEqual("FF4F81BD", color); - color = wb.Theme.ResolveThemeColor(XLThemeColor.Background1).Color.ToHex(); - Assert.AreEqual("FFFFFFFF", color); - } + color = wb.Theme.ResolveThemeColor(XLThemeColor.Background1).Color.ToHex(); + Assert.AreEqual("FFFFFFFF", color); } [Theory] public void CanResolveAllThemeColors(XLThemeColor themeColor) { - var theme = new XLWorkbook().Theme; + using var xLWorkbook = new XLWorkbook(); + var theme = xLWorkbook.Theme; var color = theme.ResolveThemeColor(themeColor); Assert.IsNotNull(color); } @@ -86,26 +85,24 @@ public void CanResolveAllThemeColors(XLThemeColor themeColor) [Test] public void SetStyleViaRowReference() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Style + .Font.SetFontSize(8) + .Font.SetFontColor(XLColor.Green) + .Font.SetBold(true); + + var row = ws.Row(1); + ws.Cell(1, 1).Value = "Test"; + row.Cell(2).Value = "Test"; + row.Cells(3, 3).Value = "Test"; + + foreach (var cell in ws.CellsUsed()) { - var ws = wb.AddWorksheet("Sheet1"); - ws.Style - .Font.SetFontSize(8) - .Font.SetFontColor(XLColor.Green) - .Font.SetBold(true); - - var row = ws.Row(1); - ws.Cell(1, 1).Value = "Test"; - row.Cell(2).Value = "Test"; - row.Cells(3, 3).Value = "Test"; - - foreach (var cell in ws.CellsUsed()) - { - Assert.AreEqual(8, ws.Cell("A1").Style.Font.FontSize); - Assert.AreEqual(XLColor.Green, ws.Cell("B1").Style.Font.FontColor); - Assert.AreEqual(true, ws.Cell("C1").Style.Font.Bold); - } + Assert.AreEqual(8, ws.Cell("A1").Style.Font.FontSize); + Assert.AreEqual(XLColor.Green, ws.Cell("B1").Style.Font.FontColor); + Assert.AreEqual(true, ws.Cell("C1").Style.Font.Bold); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/XLWorkbookTests.cs b/ClosedXML.Tests/Excel/Misc/XLWorkbookTests.cs index 33213b237..bbff5e705 100644 --- a/ClosedXML.Tests/Excel/Misc/XLWorkbookTests.cs +++ b/ClosedXML.Tests/Excel/Misc/XLWorkbookTests.cs @@ -4,7 +4,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Misc { [TestFixture] public class XLWorkbookTests @@ -12,38 +12,38 @@ public class XLWorkbookTests [Test] public void Cell1() { - var wb = new XLWorkbook(); - IXLCell cell = wb.Cell("ABC"); + using var wb = new XLWorkbook(); + var cell = wb.Cell("ABC"); Assert.IsNull(cell); } [Test] public void Cell2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet); - IXLCell cell = wb.Cell("Sheet1!Result"); + var cell = wb.Cell("Sheet1!Result"); Assert.IsNotNull(cell); - Assert.AreEqual(1, cell.GetValue()); + Assert.AreEqual(1, cell.GetValue()); } [Test] public void Cell3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result"); - IXLCell cell = wb.Cell("Sheet1!Result"); + var cell = wb.Cell("Sheet1!Result"); Assert.IsNotNull(cell); - Assert.AreEqual(1, cell.GetValue()); + Assert.AreEqual(1, cell.GetValue()); } [Test] public void Cells1() { - var wb = new XLWorkbook(); - IXLCells cells = wb.Cells("ABC"); + using var wb = new XLWorkbook(); + var cells = wb.Cells("ABC"); Assert.IsNotNull(cells); Assert.AreEqual(0, cells.Count()); } @@ -51,33 +51,33 @@ public void Cells1() [Test] public void Cells2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet); - IXLCells cells = wb.Cells("Sheet1!Result, ABC"); + var cells = wb.Cells("Sheet1!Result, ABC"); Assert.IsNotNull(cells); Assert.AreEqual(1, cells.Count()); - Assert.AreEqual(1, cells.First().GetValue()); + Assert.AreEqual(1, cells.First().GetValue()); } [Test] public void Cells3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result"); - IXLCells cells = wb.Cells("Sheet1!Result, ABC"); + var cells = wb.Cells("Sheet1!Result, ABC"); Assert.IsNotNull(cells); Assert.AreEqual(1, cells.Count()); - Assert.AreEqual(1, cells.First().GetValue()); + Assert.AreEqual(1, cells.First().GetValue()); } [Test] public void GetCellFromFullAddress() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - IXLWorksheet ws2 = wb.AddWorksheet("O'Sheet 2"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var ws2 = wb.AddWorksheet("O'Sheet 2"); var c1 = ws.Cell("C123"); var c2 = ws2.Cell("B7"); @@ -98,8 +98,8 @@ public void GetCellFromFullAddress() [TestCase("Sheet1!A")] public void GetCellFromNonExistingFullAddress(string address) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); var c = wb.Cell(address); @@ -109,8 +109,8 @@ public void GetCellFromNonExistingFullAddress(string address) [Test] public void GetRangeFromFullAddress() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); var r1 = ws.Range("C123:D125"); var r2 = wb.Range("Sheet1!C123:D125"); @@ -123,8 +123,8 @@ public void GetRangeFromFullAddress() [TestCase("Sheet1!A")] public void GetRangeFromNonExistingFullAddress(string rangeAddress) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); var r = wb.Range(rangeAddress); @@ -134,8 +134,8 @@ public void GetRangeFromNonExistingFullAddress(string rangeAddress) [Test] public void GetRangesFromFullAddress() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); var r1 = ws.Ranges("A1:B2,C1:E3"); var r2 = wb.Ranges("Sheet1!A1:B2,Sheet1!C1:E3"); @@ -149,8 +149,8 @@ public void GetRangesFromFullAddress() [TestCase("Sheet1!A,Sheet1!B")] public void GetRangesFromNonExistingFullAddress(string rangesAddress) { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); var r = wb.Ranges(rangesAddress); @@ -161,116 +161,116 @@ public void GetRangesFromNonExistingFullAddress(string rangesAddress) [Test] public void NamedRange1() { - var wb = new XLWorkbook(); - IXLNamedRange range = wb.NamedRange("ABC"); + using var wb = new XLWorkbook(); + var range = wb.NamedRange("ABC"); Assert.IsNull(range); } [Test] public void NamedRange2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet); - IXLNamedRange range = wb.NamedRange("Sheet1!Result"); + var range = wb.NamedRange("Sheet1!Result"); Assert.IsNotNull(range); Assert.AreEqual(1, range.Ranges.Count); Assert.AreEqual(1, range.Ranges.Cells().Count()); - Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue()); + Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue()); } [Test] public void NamedRange3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - IXLNamedRange range = wb.NamedRange("Sheet1!Result"); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); + var range = wb.NamedRange("Sheet1!Result"); Assert.IsNull(range); } [Test] public void NamedRange4() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result"); - IXLNamedRange range = wb.NamedRange("Sheet1!Result"); + var range = wb.NamedRange("Sheet1!Result"); Assert.IsNotNull(range); Assert.AreEqual(1, range.Ranges.Count); Assert.AreEqual(1, range.Ranges.Cells().Count()); - Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue()); + Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue()); } [Test] public void Range1() { - var wb = new XLWorkbook(); - IXLRange range = wb.Range("ABC"); + using var wb = new XLWorkbook(); + var range = wb.Range("ABC"); Assert.IsNull(range); } [Test] public void Range2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet); - IXLRange range = wb.Range("Sheet1!Result"); + var range = wb.Range("Sheet1!Result"); Assert.IsNotNull(range); Assert.AreEqual(1, range.Cells().Count()); - Assert.AreEqual(1, range.FirstCell().GetValue()); + Assert.AreEqual(1, range.FirstCell().GetValue()); } [Test] public void Range3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result"); - IXLRange range = wb.Range("Sheet1!Result"); + var range = wb.Range("Sheet1!Result"); Assert.IsNotNull(range); Assert.AreEqual(1, range.Cells().Count()); - Assert.AreEqual(1, range.FirstCell().GetValue()); + Assert.AreEqual(1, range.FirstCell().GetValue()); } [Test] public void Ranges1() { - var wb = new XLWorkbook(); - IXLRanges ranges = wb.Ranges("ABC"); + using var wb = new XLWorkbook(); + var ranges = wb.Ranges("ABC"); Assert.IsNotNull(ranges); - Assert.AreEqual(0, ranges.Count()); + Assert.AreEqual(0, ranges.Count); } [Test] public void Ranges2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet); - IXLRanges ranges = wb.Ranges("Sheet1!Result, ABC"); + var ranges = wb.Ranges("Sheet1!Result, ABC"); Assert.IsNotNull(ranges); Assert.AreEqual(1, ranges.Cells().Count()); - Assert.AreEqual(1, ranges.First().FirstCell().GetValue()); + Assert.AreEqual(1, ranges.First().FirstCell().GetValue()); } [Test] public void Ranges3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue(1).AddToNamed("Result"); - IXLRanges ranges = wb.Ranges("Sheet1!Result, ABC"); + var ranges = wb.Ranges("Sheet1!Result, ABC"); Assert.IsNotNull(ranges); Assert.AreEqual(1, ranges.Cells().Count()); - Assert.AreEqual(1, ranges.First().FirstCell().GetValue()); + Assert.AreEqual(1, ranges.First().FirstCell().GetValue()); } [Test] public void WbNamedCell() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell"); Assert.AreEqual("Test", wb.Cell("TestCell").GetString()); Assert.AreEqual("Test", ws.Cell("TestCell").GetString()); @@ -279,15 +279,15 @@ public void WbNamedCell() [Test] public void WbNamedCells() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell"); ws.Cell(2, 1).SetValue("B").AddToNamed("Test2"); - IXLCells wbCells = wb.Cells("TestCell, Test2"); + var wbCells = wb.Cells("TestCell, Test2"); Assert.AreEqual("Test", wbCells.First().GetString()); Assert.AreEqual("B", wbCells.Last().GetString()); - IXLCells wsCells = ws.Cells("TestCell, Test2"); + var wsCells = ws.Cells("TestCell, Test2"); Assert.AreEqual("Test", wsCells.First().GetString()); Assert.AreEqual("B", wsCells.Last().GetString()); } @@ -295,11 +295,11 @@ public void WbNamedCells() [Test] public void WbNamedRange() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("A"); ws.Cell(2, 1).SetValue("B"); - IXLRange original = ws.Range("A1:A2"); + var original = ws.Range("A1:A2"); original.AddToNamed("TestRange"); Assert.AreEqual(original.RangeAddress.ToStringFixed(), wb.Range("TestRange").RangeAddress.ToString()); Assert.AreEqual(original.RangeAddress.ToStringFixed(), ws.Range("TestRange").RangeAddress.ToString()); @@ -308,18 +308,18 @@ public void WbNamedRange() [Test] public void WbNamedRanges() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("A"); ws.Cell(2, 1).SetValue("B"); ws.Cell(3, 1).SetValue("C").AddToNamed("Test2"); - IXLRange original = ws.Range("A1:A2"); + var original = ws.Range("A1:A2"); original.AddToNamed("TestRange"); - IXLRanges wbRanges = wb.Ranges("TestRange, Test2"); + var wbRanges = wb.Ranges("TestRange, Test2"); Assert.AreEqual(original.RangeAddress.ToStringFixed(), wbRanges.First().RangeAddress.ToString()); Assert.AreEqual("$A$3:$A$3", wbRanges.Last().RangeAddress.ToStringFixed()); - IXLRanges wsRanges = wb.Ranges("TestRange, Test2"); + var wsRanges = wb.Ranges("TestRange, Test2"); Assert.AreEqual(original.RangeAddress.ToStringFixed(), wsRanges.First().RangeAddress.ToString()); Assert.AreEqual("$A$3:$A$3", wsRanges.Last().RangeAddress.ToStringFixed()); } @@ -327,15 +327,15 @@ public void WbNamedRanges() [Test] public void WbNamedRangesOneString() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); wb.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3"); - IXLRanges wbRanges = ws.Ranges("TestRange"); + var wbRanges = ws.Ranges("TestRange"); Assert.AreEqual("$A$1:$A$1", wbRanges.First().RangeAddress.ToStringFixed()); Assert.AreEqual("$A$3:$A$3", wbRanges.Last().RangeAddress.ToStringFixed()); - IXLRanges wsRanges = ws.Ranges("TestRange"); + var wsRanges = ws.Ranges("TestRange"); Assert.AreEqual("$A$1:$A$1", wsRanges.First().RangeAddress.ToStringFixed()); Assert.AreEqual("$A$3:$A$3", wsRanges.Last().RangeAddress.ToStringFixed()); } @@ -343,106 +343,94 @@ public void WbNamedRangesOneString() [Test] public void WbProtect1() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - wb.Protect(); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsFalse(wb.IsPasswordProtected); - } + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); + wb.Protect(); + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsFalse(wb.IsPasswordProtected); } [Test] public void WbProtect2() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - wb.Protect(true, false); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsFalse(wb.IsPasswordProtected); - } + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); +#pragma warning disable CS0618 // Type or member is obsolete, but still should be tested + wb.Protect(true, false); +#pragma warning restore CS0618 // Type or member is obsolete, but still should be tested + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsFalse(wb.IsPasswordProtected); } [Test] public void WbProtect3() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - wb.Protect("Abc@123"); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsTrue(wb.IsPasswordProtected); - Assert.Throws(() => wb.Protect()); - Assert.Throws(() => wb.Unprotect()); - Assert.Throws(() => wb.Unprotect("Cde@345")); - } + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); + wb.Protect("Abc@123"); + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsTrue(wb.IsPasswordProtected); + Assert.Throws(() => wb.Protect()); + Assert.Throws(() => wb.Unprotect()); + Assert.Throws(() => wb.Unprotect("Cde@345")); } [Test] public void WbProtect4() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - wb.Protect(); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsFalse(wb.IsPasswordProtected); - wb.Unprotect(); - wb.Protect("Abc@123"); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsTrue(wb.IsPasswordProtected); - } + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); + wb.Protect(); + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsFalse(wb.IsPasswordProtected); + wb.Unprotect(); + wb.Protect("Abc@123"); + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsTrue(wb.IsPasswordProtected); } [Test] public void WbProtect5() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - wb.Protect(true, false, "Abc@123"); - Assert.IsTrue(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsTrue(wb.IsPasswordProtected); - wb.Unprotect("Abc@123"); - Assert.IsFalse(wb.LockStructure); - Assert.IsFalse(wb.LockWindows); - Assert.IsFalse(wb.IsPasswordProtected); - } + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); +#pragma warning disable CS0618 // Type or member is obsolete, but still should be tested + wb.Protect(true, false, "Abc@123"); +#pragma warning restore CS0618 // Type or member is obsolete, but still should be tested + Assert.IsTrue(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsTrue(wb.IsPasswordProtected); + wb.Unprotect("Abc@123"); + Assert.IsFalse(wb.LockStructure); + Assert.IsFalse(wb.LockWindows); + Assert.IsFalse(wb.IsPasswordProtected); } [Test] public void FileSharingProperties() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet("Sheet1").Cell("A1").Value = "Hello world!"; - wb.FileSharing.ReadOnlyRecommended = true; - wb.FileSharing.UserName = Environment.UserName; - wb.SaveAs(ms); - } - - ms.Seek(0, SeekOrigin.Begin); - - using (var wb = new XLWorkbook(ms)) - { - Assert.IsTrue(wb.FileSharing.ReadOnlyRecommended); - Assert.AreEqual(Environment.UserName, wb.FileSharing.UserName); - } + wb.AddWorksheet("Sheet1").Cell("A1").Value = "Hello world!"; + wb.FileSharing.ReadOnlyRecommended = true; + wb.FileSharing.UserName = Environment.UserName; + wb.SaveAs(ms); } - } -#if _NET40_ - [Ignore(".NET 40 does not support Janitor.Fody")] -#endif + ms.Seek(0, SeekOrigin.Begin); + + using (var wb = new XLWorkbook(ms)) + { + Assert.IsTrue(wb.FileSharing.ReadOnlyRecommended); + Assert.AreEqual(Environment.UserName, wb.FileSharing.UserName); + } + } [Test] public void AccessDisposedWorkbookThrowsException() @@ -457,4 +445,4 @@ public void AccessDisposedWorkbookThrowsException() Assert.Throws(() => Console.WriteLine(wb.Worksheets.First().FirstCell().Value)); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Misc/XlHelperTests.cs b/ClosedXML.Tests/Excel/Misc/XlHelperTests.cs index e963a208a..d24e44b17 100644 --- a/ClosedXML.Tests/Excel/Misc/XlHelperTests.cs +++ b/ClosedXML.Tests/Excel/Misc/XlHelperTests.cs @@ -3,7 +3,7 @@ using System; using System.Collections.Generic; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Misc { [TestFixture] public class XlHelperTests @@ -95,8 +95,8 @@ public void ValidA1Addresses() [Test] public void TestColumnLetterLookup() { - var columnLetters = new List(); - for (int c = 1; c <= XLHelper.MaxColumnNumber; c++) + var columnLetters = new List(); + for (var c = 1; c <= XLHelper.MaxColumnNumber; c++) { var columnLetter = NaiveGetColumnLetterFromNumber(c); columnLetters.Add(columnLetter); @@ -149,7 +149,10 @@ public void InvalidRCAddresses(string address) /// The column letter to translate into a column number. private static int NaiveGetColumnNumberFromLetter(string columnLetter) { - if (string.IsNullOrEmpty(columnLetter)) throw new ArgumentNullException("columnLetter"); + if (string.IsNullOrEmpty(columnLetter)) + { + throw new ArgumentNullException("columnLetter"); + } int retVal; columnLetter = columnLetter.ToUpper(); @@ -157,16 +160,16 @@ private static int NaiveGetColumnNumberFromLetter(string columnLetter) //Extra check because we allow users to pass row col positions in as strings if (columnLetter[0] <= '9') { - retVal = Int32.Parse(columnLetter, XLHelper.NumberStyle, XLHelper.ParseCulture); + retVal = int.Parse(columnLetter, XLHelper.NumberStyle, XLHelper.ParseCulture); return retVal; } - int sum = 0; + var sum = 0; - for (int i = 0; i < columnLetter.Length; i++) + for (var i = 0; i < columnLetter.Length; i++) { sum *= 26; - sum += (columnLetter[i] - 'A' + 1); + sum += columnLetter[i] - 'A' + 1; } return sum; @@ -180,15 +183,18 @@ private static int NaiveGetColumnNumberFromLetter(string columnLetter) /// private static string NaiveGetColumnLetterFromNumber(int columnNumber, bool trimToAllowed = false) { - if (trimToAllowed) columnNumber = XLHelper.TrimColumnNumber(columnNumber); + if (trimToAllowed) + { + columnNumber = XLHelper.TrimColumnNumber(columnNumber); + } columnNumber--; // Adjust for start on column 1 if (columnNumber <= 25) { return letters[columnNumber]; } - var firstPart = (columnNumber) / 26; - var remainder = ((columnNumber) % 26) + 1; + var firstPart = columnNumber / 26; + var remainder = columnNumber % 26 + 1; return NaiveGetColumnLetterFromNumber(firstPart) + NaiveGetColumnLetterFromNumber(remainder); } diff --git a/ClosedXML.Tests/Excel/Misc/XmlEncoderTests.cs b/ClosedXML.Tests/Excel/Misc/XmlEncoderTests.cs index 532d95b08..5a91e0675 100644 --- a/ClosedXML.Tests/Excel/Misc/XmlEncoderTests.cs +++ b/ClosedXML.Tests/Excel/Misc/XmlEncoderTests.cs @@ -1,7 +1,7 @@ using ClosedXML.Utils; using NUnit.Framework; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Misc { [TestFixture] public class XmlEncoderTest diff --git a/ClosedXML.Tests/Excel/NamedRanges/NamedRangesTests.cs b/ClosedXML.Tests/Excel/NamedRanges/NamedRangesTests.cs index b1e856530..8fa8646df 100644 --- a/ClosedXML.Tests/Excel/NamedRanges/NamedRangesTests.cs +++ b/ClosedXML.Tests/Excel/NamedRanges/NamedRangesTests.cs @@ -5,7 +5,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.NamedRanges { [TestFixture] public class NamedRangesTests @@ -13,23 +13,21 @@ public class NamedRangesTests [Test] public void CanEvaluateNamedMultiRange() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - ws1.Range("A1:C1").Value = 1; - ws1.Range("A3:C3").Value = 3; - wb.NamedRanges.Add("TEST", ws1.Ranges("A1:C1,A3:C3")); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + ws1.Range("A1:C1").Value = 1; + ws1.Range("A3:C3").Value = 3; + wb.NamedRanges.Add("TEST", ws1.Ranges("A1:C1,A3:C3")); - ws1.Cell(2, 1).FormulaA1 = "=SUM(TEST)"; + ws1.Cell(2, 1).FormulaA1 = "=SUM(TEST)"; - Assert.AreEqual(12.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); - } + Assert.AreEqual(12.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); } [Test] public void CanGetNamedFromAnother() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); ws1.Cell("A1").SetValue(1).AddToNamed("value1"); @@ -56,125 +54,121 @@ public void CanGetNamedFromAnother() [Test] public void CanGetValidNamedRanges() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet 1"); - var ws2 = wb.Worksheets.Add("Sheet 2"); - var ws3 = wb.Worksheets.Add("Sheet'3"); - - ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); - ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); - ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); - ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); - wb.NamedRanges.Add("Named range 5", new XLRanges + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet 1"); + var ws2 = wb.Worksheets.Add("Sheet 2"); + var ws3 = wb.Worksheets.Add("Sheet'3"); + + ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); + ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); + ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); + ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); + wb.NamedRanges.Add("Named range 5", new XLRanges { ws1.Range("A5:D5"), ws3.Range("A5:D5") }); - ws2.Delete(); - ws3.Delete(); + ws2.Delete(); + ws3.Delete(); - var globalValidRanges = wb.NamedRanges.ValidNamedRanges(); - var globalInvalidRanges = wb.NamedRanges.InvalidNamedRanges(); - var localValidRanges = ws1.NamedRanges.ValidNamedRanges(); - var localInvalidRanges = ws1.NamedRanges.InvalidNamedRanges(); + var globalValidRanges = wb.NamedRanges.ValidNamedRanges(); + var globalInvalidRanges = wb.NamedRanges.InvalidNamedRanges(); + var localValidRanges = ws1.NamedRanges.ValidNamedRanges(); + var localInvalidRanges = ws1.NamedRanges.InvalidNamedRanges(); - Assert.AreEqual(1, globalValidRanges.Count()); - Assert.AreEqual("Named range 2", globalValidRanges.First().Name); + Assert.AreEqual(1, globalValidRanges.Count()); + Assert.AreEqual("Named range 2", globalValidRanges.First().Name); - Assert.AreEqual(2, globalInvalidRanges.Count()); - Assert.AreEqual("Named range 4", globalInvalidRanges.First().Name); - Assert.AreEqual("Named range 5", globalInvalidRanges.Last().Name); + Assert.AreEqual(2, globalInvalidRanges.Count()); + Assert.AreEqual("Named range 4", globalInvalidRanges.First().Name); + Assert.AreEqual("Named range 5", globalInvalidRanges.Last().Name); - Assert.AreEqual(1, localValidRanges.Count()); - Assert.AreEqual("Named range 1", localValidRanges.First().Name); + Assert.AreEqual(1, localValidRanges.Count()); + Assert.AreEqual("Named range 1", localValidRanges.First().Name); - Assert.AreEqual(0, localInvalidRanges.Count()); - } + Assert.AreEqual(0, localInvalidRanges.Count()); } [Test] public void CanRenameNamedRange() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - var nr1 = wb.NamedRanges.Add("TEST", "=0.1"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + var nr1 = wb.NamedRanges.Add("TEST", "=0.1"); - Assert.IsTrue(wb.NamedRanges.TryGetValue("TEST", out IXLNamedRange _)); - Assert.IsFalse(wb.NamedRanges.TryGetValue("TEST1", out IXLNamedRange _)); + Assert.IsTrue(wb.NamedRanges.TryGetValue("TEST", out var _)); + Assert.IsFalse(wb.NamedRanges.TryGetValue("TEST1", out var _)); - nr1.Name = "TEST1"; + nr1.Name = "TEST1"; - Assert.IsFalse(wb.NamedRanges.TryGetValue("TEST", out IXLNamedRange _)); - Assert.IsTrue(wb.NamedRanges.TryGetValue("TEST1", out IXLNamedRange _)); + Assert.IsFalse(wb.NamedRanges.TryGetValue("TEST", out var _)); + Assert.IsTrue(wb.NamedRanges.TryGetValue("TEST1", out var _)); - var nr2 = wb.NamedRanges.Add("TEST2", "=TEST1*2"); + var nr2 = wb.NamedRanges.Add("TEST2", "=TEST1*2"); - ws1.Cell(1, 1).FormulaA1 = "TEST1"; - ws1.Cell(2, 1).FormulaA1 = "TEST1*10"; - ws1.Cell(3, 1).FormulaA1 = "TEST2"; - ws1.Cell(4, 1).FormulaA1 = "TEST2*3"; + ws1.Cell(1, 1).FormulaA1 = "TEST1"; + ws1.Cell(2, 1).FormulaA1 = "TEST1*10"; + ws1.Cell(3, 1).FormulaA1 = "TEST2"; + ws1.Cell(4, 1).FormulaA1 = "TEST2*3"; - Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); - } + Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); } [Test] public void CanSaveAndLoadNamedRanges() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var sheet1 = wb.Worksheets.Add("Sheet1"); - var sheet2 = wb.Worksheets.Add("Sheet2"); + var sheet1 = wb.Worksheets.Add("Sheet1"); + var sheet2 = wb.Worksheets.Add("Sheet2"); - wb.NamedRanges.Add("wbNamedRange", - "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G"); - sheet1.NamedRanges.Add("sheet1NamedRange", - "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G"); - sheet2.NamedRanges.Add("sheet2NamedRange", "Sheet1!A1,Sheet2!A1"); + wb.NamedRanges.Add("wbNamedRange", + "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G"); + sheet1.NamedRanges.Add("sheet1NamedRange", + "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G"); + sheet2.NamedRanges.Add("sheet2NamedRange", "Sheet1!A1,Sheet2!A1"); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var sheet1 = wb.Worksheet("Sheet1"); - var sheet2 = wb.Worksheet("Sheet2"); - - Assert.AreEqual(1, wb.NamedRanges.Count()); - Assert.AreEqual("wbNamedRange", wb.NamedRanges.Single().Name); - Assert.AreEqual("Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G", wb.NamedRanges.Single().RefersTo); - Assert.AreEqual(5, wb.NamedRanges.Single().Ranges.Count); - - Assert.AreEqual(1, sheet1.NamedRanges.Count()); - Assert.AreEqual("sheet1NamedRange", sheet1.NamedRanges.Single().Name); - Assert.AreEqual("Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G", sheet1.NamedRanges.Single().RefersTo); - Assert.AreEqual(5, sheet1.NamedRanges.Single().Ranges.Count); - - Assert.AreEqual(1, sheet2.NamedRanges.Count()); - Assert.AreEqual("sheet2NamedRange", sheet2.NamedRanges.Single().Name); - Assert.AreEqual("Sheet1!A1,Sheet2!A1", sheet2.NamedRanges.Single().RefersTo); - Assert.AreEqual(2, sheet2.NamedRanges.Single().Ranges.Count); - } + using (var wb = new XLWorkbook(ms)) + { + var sheet1 = wb.Worksheet("Sheet1"); + var sheet2 = wb.Worksheet("Sheet2"); + + Assert.AreEqual(1, wb.NamedRanges.Count()); + Assert.AreEqual("wbNamedRange", wb.NamedRanges.Single().Name); + Assert.AreEqual("Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G", wb.NamedRanges.Single().RefersTo); + Assert.AreEqual(5, wb.NamedRanges.Single().Ranges.Count); + + Assert.AreEqual(1, sheet1.NamedRanges.Count()); + Assert.AreEqual("sheet1NamedRange", sheet1.NamedRanges.Single().Name); + Assert.AreEqual("Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G", sheet1.NamedRanges.Single().RefersTo); + Assert.AreEqual(5, sheet1.NamedRanges.Single().Ranges.Count); + + Assert.AreEqual(1, sheet2.NamedRanges.Count()); + Assert.AreEqual("sheet2NamedRange", sheet2.NamedRanges.Single().Name); + Assert.AreEqual("Sheet1!A1,Sheet2!A1", sheet2.NamedRanges.Single().RefersTo); + Assert.AreEqual(2, sheet2.NamedRanges.Single().Ranges.Count); } } [Test] public void CopyNamedRangeDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var ws2 = wb.Worksheets.Add("Sheet2"); - var ranges = new XLRanges(); - ranges.Add(ws1.Range("B2:E6")); - ranges.Add(ws2.Range("D1:E2")); + var ranges = new XLRanges + { + ws1.Range("B2:E6"), + ws2.Range("D1:E2") + }; var original = ws1.NamedRanges.Add("Named range", ranges); var copy = original.CopyTo(ws2); @@ -194,12 +188,12 @@ public void CopyNamedRangeDifferentWorksheets() [Test] public void CopyNamedRangeSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); ws1.Range("B2:E6").AddToNamed("Named range", XLScope.Worksheet); var nr = ws1.NamedRange("Named range"); - TestDelegate action = () => nr.CopyTo(ws1); + void action() => nr.CopyTo(ws1); Assert.Throws(typeof(InvalidOperationException), action); } @@ -207,29 +201,27 @@ public void CopyNamedRangeSameWorksheet() [Test] public void DeleteColumnUsedInNamedRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Column1"); - ws.FirstCell().CellRight().SetValue("Column2").Style.Font.SetBold(); - ws.FirstCell().CellRight(2).SetValue("Column3"); - ws.NamedRanges.Add("MyRange", "A1:C1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Column1"); + ws.FirstCell().CellRight().SetValue("Column2").Style.Font.SetBold(); + ws.FirstCell().CellRight(2).SetValue("Column3"); + ws.NamedRanges.Add("MyRange", "A1:C1"); - ws.Column(1).Delete(); + ws.Column(1).Delete(); - Assert.IsTrue(ws.Cell("A1").Style.Font.Bold); - Assert.AreEqual("Column3", ws.Cell("B1").GetValue()); - Assert.IsEmpty(ws.Cell("C1").GetValue()); - } + Assert.IsTrue(ws.Cell("A1").Style.Font.Bold); + Assert.AreEqual("Column3", ws.Cell("B1").GetValue()); + Assert.IsEmpty(ws.Cell("C1").GetValue()); } [Test] public void MovingRanges() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); - IXLWorksheet sheet1 = wb.Worksheets.Add("Sheet1"); - IXLWorksheet sheet2 = wb.Worksheets.Add("Sheet2"); + var sheet1 = wb.Worksheets.Add("Sheet1"); + var sheet2 = wb.Worksheets.Add("Sheet2"); wb.NamedRanges.Add("wbNamedRange", "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G"); @@ -256,164 +248,154 @@ public void MovingRanges() [Test, Ignore("Muted until shifting is fixed (see #880)")] public void NamedRangeBecomesInvalidOnRangeAndWorksheetDeleting() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet 1"); - var ws2 = wb.Worksheets.Add("Sheet 2"); - ws1.Range("A1:B2").AddToNamed("Simple", XLScope.Workbook); - wb.NamedRanges.Add("Compound", new XLRanges + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet 1"); + var ws2 = wb.Worksheets.Add("Sheet 2"); + ws1.Range("A1:B2").AddToNamed("Simple", XLScope.Workbook); + wb.NamedRanges.Add("Compound", new XLRanges { ws1.Range("C1:D2"), ws2.Range("A10:D15") }); - ws1.Rows(1, 5).Delete(); - ws1.Delete(); + ws1.Rows(1, 5).Delete(); + ws1.Delete(); - Assert.AreEqual(2, wb.NamedRanges.Count()); - Assert.AreEqual(0, wb.NamedRanges.ValidNamedRanges().Count()); - Assert.AreEqual("#REF!#REF!", wb.NamedRanges.ElementAt(0).RefersTo); - Assert.AreEqual("#REF!#REF!,'Sheet 2'!A10:D15", wb.NamedRanges.ElementAt(0).RefersTo); - } + Assert.AreEqual(2, wb.NamedRanges.Count()); + Assert.AreEqual(0, wb.NamedRanges.ValidNamedRanges().Count()); + Assert.AreEqual("#REF!#REF!", wb.NamedRanges.ElementAt(0).RefersTo); + Assert.AreEqual("#REF!#REF!,'Sheet 2'!A10:D15", wb.NamedRanges.ElementAt(0).RefersTo); } [Test, Ignore("Muted until shifting is fixed (see #880)")] public void NamedRangeBecomesInvalidOnRangeDeleting() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet 1"); - ws.Range("A1:B2").AddToNamed("Simple", XLScope.Workbook); - wb.NamedRanges.Add("Compound", new XLRanges + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet 1"); + ws.Range("A1:B2").AddToNamed("Simple", XLScope.Workbook); + wb.NamedRanges.Add("Compound", new XLRanges { ws.Range("C1:D2"), ws.Range("A10:D15") }); - ws.Rows(1, 5).Delete(); + ws.Rows(1, 5).Delete(); - Assert.AreEqual(2, wb.NamedRanges.Count()); - Assert.AreEqual(0, wb.NamedRanges.ValidNamedRanges().Count()); - Assert.AreEqual("'Sheet 1'!#REF!", wb.NamedRanges.ElementAt(0).RefersTo); - Assert.AreEqual("'Sheet 1'!#REF!,'Sheet 1'!A5:D10", wb.NamedRanges.ElementAt(0).RefersTo); - } + Assert.AreEqual(2, wb.NamedRanges.Count()); + Assert.AreEqual(0, wb.NamedRanges.ValidNamedRanges().Count()); + Assert.AreEqual("'Sheet 1'!#REF!", wb.NamedRanges.ElementAt(0).RefersTo); + Assert.AreEqual("'Sheet 1'!#REF!,'Sheet 1'!A5:D10", wb.NamedRanges.ElementAt(0).RefersTo); } [Test] public void NamedRangeMayReferToExpression() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - wb.NamedRanges.Add("TEST", "=0.1"); - wb.NamedRanges.Add("TEST2", "=TEST*2"); + var ws1 = wb.AddWorksheet("Sheet1"); + wb.NamedRanges.Add("TEST", "=0.1"); + wb.NamedRanges.Add("TEST2", "=TEST*2"); - ws1.Cell(1, 1).FormulaA1 = "TEST"; - ws1.Cell(2, 1).FormulaA1 = "TEST*10"; - ws1.Cell(3, 1).FormulaA1 = "TEST2"; - ws1.Cell(4, 1).FormulaA1 = "TEST2*3"; + ws1.Cell(1, 1).FormulaA1 = "TEST"; + ws1.Cell(2, 1).FormulaA1 = "TEST*10"; + ws1.Cell(3, 1).FormulaA1 = "TEST2"; + ws1.Cell(4, 1).FormulaA1 = "TEST2*3"; - Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws1 = wb.Worksheets.First(); + using (var wb = new XLWorkbook(ms)) + { + var ws1 = wb.Worksheets.First(); - Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); - Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); - } + Assert.AreEqual(0.1, (double)ws1.Cell(1, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(1.0, (double)ws1.Cell(2, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.2, (double)ws1.Cell(3, 1).Value, XLHelper.Epsilon); + Assert.AreEqual(0.6, (double)ws1.Cell(4, 1).Value, XLHelper.Epsilon); } } [Test] public void NamedRangeReferringToMultipleRangesCanBeSavedAndLoaded() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet 1"); + var ws = wb.Worksheets.Add("Sheet 1"); - wb.NamedRanges.Add("Multirange named range", new XLRanges + wb.NamedRanges.Add("Multirange named range", new XLRanges { ws.Range("A5:D5"), ws.Range("A15:D15") }); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual(1, wb.NamedRanges.Count()); - var nr = wb.NamedRanges.Single() as XLNamedRange; - Assert.AreEqual("'Sheet 1'!$A$5:$D$5,'Sheet 1'!$A$15:$D$15", nr.RefersTo); - Assert.AreEqual(2, nr.Ranges.Count); - Assert.AreEqual("'Sheet 1'!A5:D5", nr.Ranges.First().RangeAddress.ToString(XLReferenceStyle.A1, true)); - Assert.AreEqual("'Sheet 1'!A15:D15", nr.Ranges.Last().RangeAddress.ToString(XLReferenceStyle.A1, true)); - Assert.AreEqual(2, nr.RangeList.Count); - Assert.AreEqual("'Sheet 1'!$A$5:$D$5", nr.RangeList.First()); - Assert.AreEqual("'Sheet 1'!$A$15:$D$15", nr.RangeList.Last()); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual(1, wb.NamedRanges.Count()); + var nr = wb.NamedRanges.Single() as XLNamedRange; + Assert.AreEqual("'Sheet 1'!$A$5:$D$5,'Sheet 1'!$A$15:$D$15", nr.RefersTo); + Assert.AreEqual(2, nr.Ranges.Count); + Assert.AreEqual("'Sheet 1'!A5:D5", nr.Ranges.First().RangeAddress.ToString(XLReferenceStyle.A1, true)); + Assert.AreEqual("'Sheet 1'!A15:D15", nr.Ranges.Last().RangeAddress.ToString(XLReferenceStyle.A1, true)); + Assert.AreEqual(2, nr.RangeList.Count); + Assert.AreEqual("'Sheet 1'!$A$5:$D$5", nr.RangeList.First()); + Assert.AreEqual("'Sheet 1'!$A$15:$D$15", nr.RangeList.Last()); } } [Test] public void NamedRangesBecomeInvalidOnWorksheetDeleting() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet 1"); - var ws2 = wb.Worksheets.Add("Sheet 2"); - var ws3 = wb.Worksheets.Add("Sheet'3"); - - ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); - ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); - ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); - ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); - wb.NamedRanges.Add("Named range 5", new XLRanges + using var wb = new XLWorkbook(); + var ws1 = wb.Worksheets.Add("Sheet 1"); + var ws2 = wb.Worksheets.Add("Sheet 2"); + var ws3 = wb.Worksheets.Add("Sheet'3"); + + ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); + ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); + ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); + ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); + wb.NamedRanges.Add("Named range 5", new XLRanges { ws1.Range("A5:D5"), ws3.Range("A5:D5") }); - ws2.Delete(); - ws3.Delete(); + ws2.Delete(); + ws3.Delete(); - Assert.AreEqual(1, ws1.NamedRanges.Count()); - Assert.AreEqual("Named range 1", ws1.NamedRanges.First().Name); - Assert.AreEqual(XLNamedRangeScope.Worksheet, ws1.NamedRanges.First().Scope); - Assert.AreEqual("'Sheet 1'!$A$1:$D$1", ws1.NamedRanges.First().RefersTo); - Assert.AreEqual("'Sheet 1'!A1:D1", ws1.NamedRanges.First().Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - - Assert.AreEqual(3, wb.NamedRanges.Count()); - - Assert.AreEqual("Named range 2", wb.NamedRanges.ElementAt(0).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(0).Scope); - Assert.AreEqual("'Sheet 1'!$A$2:$D$2", wb.NamedRanges.ElementAt(0).RefersTo); - Assert.AreEqual("'Sheet 1'!A2:D2", wb.NamedRanges.ElementAt(0).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - - Assert.AreEqual("Named range 4", wb.NamedRanges.ElementAt(1).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(1).Scope); - Assert.AreEqual("#REF!$A$4:$D$4", wb.NamedRanges.ElementAt(1).RefersTo); - Assert.IsFalse(wb.NamedRanges.ElementAt(1).Ranges.Any()); - - Assert.AreEqual("Named range 5", wb.NamedRanges.ElementAt(2).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(2).Scope); - Assert.AreEqual("'Sheet 1'!$A$5:$D$5,#REF!$A$5:$D$5", wb.NamedRanges.ElementAt(2).RefersTo); - Assert.AreEqual(1, wb.NamedRanges.ElementAt(2).Ranges.Count); - Assert.AreEqual("'Sheet 1'!A5:D5", wb.NamedRanges.ElementAt(2).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - } + Assert.AreEqual(1, ws1.NamedRanges.Count()); + Assert.AreEqual("Named range 1", ws1.NamedRanges.First().Name); + Assert.AreEqual(XLNamedRangeScope.Worksheet, ws1.NamedRanges.First().Scope); + Assert.AreEqual("'Sheet 1'!$A$1:$D$1", ws1.NamedRanges.First().RefersTo); + Assert.AreEqual("'Sheet 1'!A1:D1", ws1.NamedRanges.First().Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); + + Assert.AreEqual(3, wb.NamedRanges.Count()); + + Assert.AreEqual("Named range 2", wb.NamedRanges.ElementAt(0).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(0).Scope); + Assert.AreEqual("'Sheet 1'!$A$2:$D$2", wb.NamedRanges.ElementAt(0).RefersTo); + Assert.AreEqual("'Sheet 1'!A2:D2", wb.NamedRanges.ElementAt(0).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); + + Assert.AreEqual("Named range 4", wb.NamedRanges.ElementAt(1).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(1).Scope); + Assert.AreEqual("#REF!$A$4:$D$4", wb.NamedRanges.ElementAt(1).RefersTo); + Assert.IsFalse(wb.NamedRanges.ElementAt(1).Ranges.Any()); + + Assert.AreEqual("Named range 5", wb.NamedRanges.ElementAt(2).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(2).Scope); + Assert.AreEqual("'Sheet 1'!$A$5:$D$5,#REF!$A$5:$D$5", wb.NamedRanges.ElementAt(2).RefersTo); + Assert.AreEqual(1, wb.NamedRanges.ElementAt(2).Ranges.Count); + Assert.AreEqual("'Sheet 1'!A5:D5", wb.NamedRanges.ElementAt(2).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); } [Test] @@ -423,142 +405,134 @@ public void NamedRangesFromDeletedSheetAreSavedWithoutAddress() // But workbooks with such references in named ranges Excel considers as broken files. // It requires #REF! - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add("Sheet 1"); - var ws2 = wb.Worksheets.Add("Sheet 2"); - ws2.Range("A4:D4").AddToNamed("Test named range", XLScope.Workbook); - ws2.Delete(); - wb.SaveAs(ms); - } - - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual("#REF!", wb.NamedRanges.Single().RefersTo); - } + wb.Worksheets.Add("Sheet 1"); + var ws2 = wb.Worksheets.Add("Sheet 2"); + ws2.Range("A4:D4").AddToNamed("Test named range", XLScope.Workbook); + ws2.Delete(); + wb.SaveAs(ms); + } + + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual("#REF!", wb.NamedRanges.Single().RefersTo); } } [Test] public void NamedRangesWhenCopyingWorksheets() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - ws1.FirstCell().Value = Enumerable.Range(1, 10); - wb.NamedRanges.Add("wbNamedRange", ws1.Range("A1:A10")); - ws1.NamedRanges.Add("wsNamedRange", ws1.Range("A3")); - - var ws2 = wb.AddWorksheet("Sheet2"); - ws2.FirstCell().Value = Enumerable.Range(101, 10); - ws1.NamedRanges.Add("wsNamedRangeAcrossSheets", ws2.Range("A4")); - - ws1.Cell("C1").FormulaA1 = "=wbNamedRange"; - ws1.Cell("C2").FormulaA1 = "=wsNamedRange"; - ws1.Cell("C3").FormulaA1 = "=wsNamedRangeAcrossSheets"; - - Assert.AreEqual(1, ws1.Cell("C1").Value); - Assert.AreEqual(3, ws1.Cell("C2").Value); - Assert.AreEqual(104, ws1.Cell("C3").Value); - - var wsCopy = ws1.CopyTo("Copy"); - Assert.AreEqual(1, wsCopy.Cell("C1").Value); - Assert.AreEqual(3, wsCopy.Cell("C2").Value); - Assert.AreEqual(104, wsCopy.Cell("C3").Value); - - Assert.AreEqual("Sheet1!A1:A10", - wb.NamedRange("wbNamedRange").Ranges.First().RangeAddress.ToStringRelative(true)); - Assert.AreEqual("Copy!A3:A3", - wsCopy.NamedRange("wsNamedRange").Ranges.First().RangeAddress.ToStringRelative(true)); - Assert.AreEqual("Sheet2!A4:A4", - wsCopy.NamedRange("wsNamedRangeAcrossSheets").Ranges.First().RangeAddress.ToStringRelative(true)); - } + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + ws1.FirstCell().Value = Enumerable.Range(1, 10); + wb.NamedRanges.Add("wbNamedRange", ws1.Range("A1:A10")); + ws1.NamedRanges.Add("wsNamedRange", ws1.Range("A3")); + + var ws2 = wb.AddWorksheet("Sheet2"); + ws2.FirstCell().Value = Enumerable.Range(101, 10); + ws1.NamedRanges.Add("wsNamedRangeAcrossSheets", ws2.Range("A4")); + + ws1.Cell("C1").FormulaA1 = "=wbNamedRange"; + ws1.Cell("C2").FormulaA1 = "=wsNamedRange"; + ws1.Cell("C3").FormulaA1 = "=wsNamedRangeAcrossSheets"; + + Assert.AreEqual(1, ws1.Cell("C1").Value); + Assert.AreEqual(3, ws1.Cell("C2").Value); + Assert.AreEqual(104, ws1.Cell("C3").Value); + + var wsCopy = ws1.CopyTo("Copy"); + Assert.AreEqual(1, wsCopy.Cell("C1").Value); + Assert.AreEqual(3, wsCopy.Cell("C2").Value); + Assert.AreEqual(104, wsCopy.Cell("C3").Value); + + Assert.AreEqual("Sheet1!A1:A10", + wb.NamedRange("wbNamedRange").Ranges.First().RangeAddress.ToStringRelative(true)); + Assert.AreEqual("Copy!A3:A3", + wsCopy.NamedRange("wsNamedRange").Ranges.First().RangeAddress.ToStringRelative(true)); + Assert.AreEqual("Sheet2!A4:A4", + wsCopy.NamedRange("wsNamedRangeAcrossSheets").Ranges.First().RangeAddress.ToStringRelative(true)); } [Test] public void SavedNamedRangesBecomeInvalidOnWorksheetDeleting() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.Worksheets.Add("Sheet 1"); - var ws2 = wb.Worksheets.Add("Sheet2"); - var ws3 = wb.Worksheets.Add("Sheet'3"); - - ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); - ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); - ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); - ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); - wb.NamedRanges.Add("Named range 5", new XLRanges + var ws1 = wb.Worksheets.Add("Sheet 1"); + var ws2 = wb.Worksheets.Add("Sheet2"); + var ws3 = wb.Worksheets.Add("Sheet'3"); + + ws1.Range("A1:D1").AddToNamed("Named range 1", XLScope.Worksheet); + ws1.Range("A2:D2").AddToNamed("Named range 2", XLScope.Workbook); + ws2.Range("A3:D3").AddToNamed("Named range 3", XLScope.Worksheet); + ws2.Range("A4:D4").AddToNamed("Named range 4", XLScope.Workbook); + wb.NamedRanges.Add("Named range 5", new XLRanges { ws1.Range("A5:D5"), ws3.Range("A5:D5") }); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - wb.Worksheet("Sheet2").Delete(); - wb.Worksheet("Sheet'3").Delete(); - wb.Save(); - } + using (var wb = new XLWorkbook(ms)) + { + wb.Worksheet("Sheet2").Delete(); + wb.Worksheet("Sheet'3").Delete(); + wb.Save(); + } - using (var wb = new XLWorkbook(ms)) - { - var ws1 = wb.Worksheet("Sheet 1"); - Assert.AreEqual(1, ws1.NamedRanges.Count()); - Assert.AreEqual("Named range 1", ws1.NamedRanges.First().Name); - Assert.AreEqual(XLNamedRangeScope.Worksheet, ws1.NamedRanges.First().Scope); - Assert.AreEqual("'Sheet 1'!$A$1:$D$1", ws1.NamedRanges.First().RefersTo); - Assert.AreEqual("'Sheet 1'!A1:D1", - ws1.NamedRanges.First().Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - - Assert.AreEqual(3, wb.NamedRanges.Count()); - - Assert.AreEqual("Named range 2", wb.NamedRanges.ElementAt(0).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(0).Scope); - Assert.AreEqual("'Sheet 1'!$A$2:$D$2", wb.NamedRanges.ElementAt(0).RefersTo); - Assert.AreEqual("'Sheet 1'!A2:D2", - wb.NamedRanges.ElementAt(0).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - - Assert.AreEqual("Named range 4", wb.NamedRanges.ElementAt(1).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(1).Scope); - Assert.AreEqual("#REF!", wb.NamedRanges.ElementAt(1).RefersTo); - Assert.IsFalse(wb.NamedRanges.ElementAt(1).Ranges.Any()); - - Assert.AreEqual("Named range 5", wb.NamedRanges.ElementAt(2).Name); - Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(2).Scope); - Assert.AreEqual("'Sheet 1'!$A$5:$D$5,#REF!", wb.NamedRanges.ElementAt(2).RefersTo); - Assert.AreEqual(1, wb.NamedRanges.ElementAt(2).Ranges.Count); - Assert.AreEqual("'Sheet 1'!A5:D5", - wb.NamedRanges.ElementAt(2).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); - } + using (var wb = new XLWorkbook(ms)) + { + var ws1 = wb.Worksheet("Sheet 1"); + Assert.AreEqual(1, ws1.NamedRanges.Count()); + Assert.AreEqual("Named range 1", ws1.NamedRanges.First().Name); + Assert.AreEqual(XLNamedRangeScope.Worksheet, ws1.NamedRanges.First().Scope); + Assert.AreEqual("'Sheet 1'!$A$1:$D$1", ws1.NamedRanges.First().RefersTo); + Assert.AreEqual("'Sheet 1'!A1:D1", + ws1.NamedRanges.First().Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); + + Assert.AreEqual(3, wb.NamedRanges.Count()); + + Assert.AreEqual("Named range 2", wb.NamedRanges.ElementAt(0).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(0).Scope); + Assert.AreEqual("'Sheet 1'!$A$2:$D$2", wb.NamedRanges.ElementAt(0).RefersTo); + Assert.AreEqual("'Sheet 1'!A2:D2", + wb.NamedRanges.ElementAt(0).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); + + Assert.AreEqual("Named range 4", wb.NamedRanges.ElementAt(1).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(1).Scope); + Assert.AreEqual("#REF!", wb.NamedRanges.ElementAt(1).RefersTo); + Assert.IsFalse(wb.NamedRanges.ElementAt(1).Ranges.Any()); + + Assert.AreEqual("Named range 5", wb.NamedRanges.ElementAt(2).Name); + Assert.AreEqual(XLNamedRangeScope.Workbook, wb.NamedRanges.ElementAt(2).Scope); + Assert.AreEqual("'Sheet 1'!$A$5:$D$5,#REF!", wb.NamedRanges.ElementAt(2).RefersTo); + Assert.AreEqual(1, wb.NamedRanges.ElementAt(2).Ranges.Count); + Assert.AreEqual("'Sheet 1'!A5:D5", + wb.NamedRanges.ElementAt(2).Ranges.Single().RangeAddress.ToString(XLReferenceStyle.A1, true)); } } [Test] public void TestInvalidNamedRangeOnWorkbookScope() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Column1"); - ws.FirstCell().CellRight().SetValue("Column2").Style.Font.SetBold(); - ws.FirstCell().CellRight(2).SetValue("Column3"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Column1"); + ws.FirstCell().CellRight().SetValue("Column2").Style.Font.SetBold(); + ws.FirstCell().CellRight(2).SetValue("Column3"); - Assert.Throws(() => wb.NamedRanges.Add("MyRange", "A1:C1")); - } + Assert.Throws(() => wb.NamedRanges.Add("MyRange", "A1:C1")); } [Test] public void WbContainsWsNamedRange() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().AddToNamed("Name", XLScope.Worksheet); @@ -568,12 +542,12 @@ public void WbContainsWsNamedRange() Assert.IsNotNull(wb.NamedRange("Sheet1!Name")); Assert.IsNull(wb.NamedRange("Sheet1!NameX")); - Boolean result1 = wb.NamedRanges.TryGetValue("Sheet1!Name", out IXLNamedRange range1); + var result1 = wb.NamedRanges.TryGetValue("Sheet1!Name", out var range1); Assert.IsTrue(result1); Assert.IsNotNull(range1); Assert.AreEqual(XLNamedRangeScope.Worksheet, range1.Scope); - Boolean result2 = wb.NamedRanges.TryGetValue("Sheet1!NameX", out IXLNamedRange range2); + var result2 = wb.NamedRanges.TryGetValue("Sheet1!NameX", out var range2); Assert.IsFalse(result2); Assert.IsNull(range2); } @@ -581,7 +555,7 @@ public void WbContainsWsNamedRange() [Test] public void WorkbookContainsNamedRange() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().AddToNamed("Name"); @@ -591,11 +565,11 @@ public void WorkbookContainsNamedRange() Assert.IsNotNull(wb.NamedRange("Name")); Assert.IsNull(wb.NamedRange("NameX")); - Boolean result1 = wb.NamedRanges.TryGetValue("Name", out IXLNamedRange range1); + var result1 = wb.NamedRanges.TryGetValue("Name", out var range1); Assert.IsTrue(result1); Assert.IsNotNull(range1); - Boolean result2 = wb.NamedRanges.TryGetValue("NameX", out IXLNamedRange range2); + var result2 = wb.NamedRanges.TryGetValue("NameX", out var range2); Assert.IsFalse(result2); Assert.IsNull(range2); } @@ -603,7 +577,7 @@ public void WorkbookContainsNamedRange() [Test] public void WorksheetContainsNamedRange() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.FirstCell().AddToNamed("Name", XLScope.Worksheet); Assert.IsTrue(ws.NamedRanges.Contains("Name")); @@ -612,11 +586,11 @@ public void WorksheetContainsNamedRange() Assert.IsNotNull(ws.NamedRange("Name")); Assert.IsNull(ws.NamedRange("NameX")); - Boolean result1 = ws.NamedRanges.TryGetValue("Name", out IXLNamedRange range1); + var result1 = ws.NamedRanges.TryGetValue("Name", out var range1); Assert.IsTrue(result1); Assert.IsNotNull(range1); - Boolean result2 = ws.NamedRanges.TryGetValue("NameX", out IXLNamedRange range2); + var result2 = ws.NamedRanges.TryGetValue("NameX", out var range2); Assert.IsFalse(result2); Assert.IsNull(range2); } @@ -636,4 +610,4 @@ public void NamedRangeWithSameNameAsAFunction() Assert.AreEqual(50, a2.GetDouble()); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/PageSetup/HeaderFooterTests.cs b/ClosedXML.Tests/Excel/PageSetup/HeaderFooterTests.cs index d40206f91..bc0c5d439 100644 --- a/ClosedXML.Tests/Excel/PageSetup/HeaderFooterTests.cs +++ b/ClosedXML.Tests/Excel/PageSetup/HeaderFooterTests.cs @@ -3,7 +3,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.PageSetup { [TestFixture] public class HeaderFooterTests @@ -11,15 +11,17 @@ public class HeaderFooterTests [Test] public void CanChangeWorksheetHeader() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); + var wb = xLWorkbook; + var ws = wb.AddWorksheet("Sheet1"); ws.PageSetup.Header.Center.AddText("Initial page header", XLHFOccurrence.EvenPages); var ms = new MemoryStream(); wb.SaveAs(ms, true); - wb = new XLWorkbook(ms); + using var xLWorkbook1 = new XLWorkbook(ms); + wb = xLWorkbook1; ws = wb.Worksheets.First(); ws.PageSetup.Header.Center.Clear(); @@ -27,7 +29,8 @@ public void CanChangeWorksheetHeader() wb.SaveAs(ms, true); - wb = new XLWorkbook(ms); + using var xLWorkbook2 = new XLWorkbook(ms); + wb = xLWorkbook2; ws = wb.Worksheets.First(); var newHeader = ws.PageSetup.Header.Center.GetText(XLHFOccurrence.EvenPages); @@ -38,14 +41,12 @@ public void CanChangeWorksheetHeader() [TestCase("&L&C&\"Arial\"&9 19-10-2017 \n&9&\"Arial\" &P &N &R")] // https://github.com/ClosedXML/ClosedXML/issues/563 public void CanSetHeaderFooter(string s) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); { - var ws = wb.AddWorksheet("Sheet1"); - { - var header = ws.PageSetup.Header as XLHeaderFooter; - header.SetInnerText(XLHFOccurrence.AllPages, s); - } + var header = ws.PageSetup.Header as XLHeaderFooter; + header.SetInnerText(XLHFOccurrence.AllPages, s); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/PageSetup/PageBreaksTests.cs b/ClosedXML.Tests/Excel/PageSetup/PageBreaksTests.cs index e17063c1e..d17e1f404 100644 --- a/ClosedXML.Tests/Excel/PageSetup/PageBreaksTests.cs +++ b/ClosedXML.Tests/Excel/PageSetup/PageBreaksTests.cs @@ -1,7 +1,7 @@ using ClosedXML.Excel; using NUnit.Framework; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.PageSetup { [TestFixture] public class PageBreaksTests @@ -9,8 +9,8 @@ public class PageBreaksTests [Test] public void RowBreaksShouldBeSorted() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddHorizontalPageBreak(10); sheet.PageSetup.AddHorizontalPageBreak(12); @@ -21,8 +21,8 @@ public void RowBreaksShouldBeSorted() [Test] public void ColumnBreaksShouldBeSorted() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddVerticalPageBreak(10); sheet.PageSetup.AddVerticalPageBreak(12); @@ -33,8 +33,8 @@ public void ColumnBreaksShouldBeSorted() [Test] public void RowBreaksShiftWhenInsertedRowAbove() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddHorizontalPageBreak(10); sheet.Row(5).InsertRowsAbove(1); @@ -44,8 +44,8 @@ public void RowBreaksShiftWhenInsertedRowAbove() [Test] public void RowBreaksNotShiftWhenInsertedRowBelow() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddHorizontalPageBreak(10); sheet.Row(15).InsertRowsAbove(1); @@ -55,8 +55,8 @@ public void RowBreaksNotShiftWhenInsertedRowBelow() [Test] public void ColumnBreaksShiftWhenInsertedColumnBefore() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddVerticalPageBreak(10); sheet.Column(5).InsertColumnsBefore(1); @@ -66,12 +66,12 @@ public void ColumnBreaksShiftWhenInsertedColumnBefore() [Test] public void ColumnBreaksNotShiftWhenInsertedColumnAfter() { - var wb = new XLWorkbook(); - IXLWorksheet sheet = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("Sheet1"); sheet.PageSetup.AddVerticalPageBreak(10); sheet.Column(15).InsertColumnsBefore(1); Assert.AreEqual(10, sheet.PageSetup.ColumnBreaks[0]); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/PivotTables/XLPivotTableTests.cs b/ClosedXML.Tests/Excel/PivotTables/XLPivotTableTests.cs index dd57e2e21..f757142e5 100644 --- a/ClosedXML.Tests/Excel/PivotTables/XLPivotTableTests.cs +++ b/ClosedXML.Tests/Excel/PivotTables/XLPivotTableTests.cs @@ -1,11 +1,13 @@ using ClosedXML.Excel; +using ClosedXML.Tests.Utils; using NUnit.Framework; using System; using System.Collections.Generic; using System.IO; using System.Linq; +using System.Runtime.InteropServices; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.PivotTables { [TestFixture] public class XLPivotTableTests @@ -15,310 +17,323 @@ public void PivotTables() { Assert.DoesNotThrow(() => { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("PastrySalesData"); - var table = ws.Table("PastrySalesData"); - var ptSheet = wb.Worksheets.Add("BlankPivotTable"); - ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PastrySalesData"); + var table = ws.Table("PastrySalesData"); + var ptSheet = wb.Worksheets.Add("BlankPivotTable"); + ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table); - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - } - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); }); } [Test] public void TestPivotTableVersioningAttributes() { + var expectedFilePath = @"Other\PivotTableReferenceFiles\VersioningAttributes\outputfile.xlsx"; + // Pivot table definitions in input file has created and refreshed versioning attributes = 3 - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\VersioningAttributes\inputfile.xlsx"))) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\VersioningAttributes\inputfile.xlsx")); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); + var wb = new XLWorkbook(stream); - var data = wb.Worksheet("Data"); + var data = wb.Worksheet("Data"); - var pt = data.RangeUsed().CreatePivotTable(wb.AddWorksheet("pvt2").FirstCell(), "pvt2"); + var pt = data.RangeUsed().CreatePivotTable(wb.AddWorksheet("pvt2").FirstCell(), "pvt2"); - pt.ColumnLabels.Add("Sex"); - pt.RowLabels.Add("FullName"); - pt.Values.Add("Id", "Count of Id").SetSummaryFormula(XLPivotSummary.Count); + pt.ColumnLabels.Add("Sex"); + pt.RowLabels.Add("FullName"); + pt.Values.Add("Id", "Count of Id").SetSummaryFormula(XLPivotSummary.Count); - return wb; - // Pivot table definitions in output file has created and refreshed versioning attributes = 5 - }, @"Other\PivotTableReferenceFiles\VersioningAttributes\outputfile.xlsx"); - } + //Uncomment to replace expectation running.net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + + return wb; + // Pivot table definitions in output file has created and refreshed versioning attributes = 5 + }, expectedFilePath); } [Test] public void PivotTableOptionsSaveTest() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("PastrySalesData"); - var table = ws.Table("PastrySalesData"); - var ptSheet = wb.Worksheets.Add("BlankPivotTable"); - var pt = ptSheet.PivotTables.Add("pvtOptionsTest", ptSheet.Cell(1, 1), table); - - pt.ColumnHeaderCaption = "clmn header"; - pt.RowHeaderCaption = "row header"; - - pt.AutofitColumns = true; - pt.PreserveCellFormatting = false; - pt.ShowGrandTotalsColumns = true; - pt.ShowGrandTotalsRows = true; - pt.UseCustomListsForSorting = false; - pt.ShowExpandCollapseButtons = false; - pt.ShowContextualTooltips = false; - pt.DisplayCaptionsAndDropdowns = false; - pt.RepeatRowLabels = true; - pt.SaveSourceData = false; - pt.EnableShowDetails = false; - pt.ShowColumnHeaders = false; - pt.ShowRowHeaders = false; - - pt.MergeAndCenterWithLabels = true; // MergeItem - pt.RowLabelIndent = 12; // Indent - pt.FilterAreaOrder = XLFilterAreaOrder.OverThenDown; // PageOverThenDown - pt.FilterFieldsPageWrap = 14; // PageWrap - pt.ErrorValueReplacement = "error test"; // ErrorCaption - pt.EmptyCellReplacement = "empty test"; // MissingCaption - - pt.FilteredItemsInSubtotals = true; // Subtotal filtered page items - pt.AllowMultipleFilters = false; // MultipleFieldFilters - - pt.ShowPropertiesInTooltips = false; - pt.ClassicPivotTableLayout = true; - pt.ShowEmptyItemsOnRows = true; - pt.ShowEmptyItemsOnColumns = true; - pt.DisplayItemLabels = false; - pt.SortFieldsAtoZ = true; - - pt.PrintExpandCollapsedButtons = true; - pt.PrintTitles = true; - - // TODO pt.RefreshDataOnOpen = false; - pt.ItemsToRetainPerField = XLItemsToRetain.Max; - pt.EnableCellEditing = true; - pt.ShowValuesRow = true; - pt.ShowRowStripes = true; - pt.ShowColumnStripes = true; - pt.Theme = XLPivotTableTheme.PivotStyleDark13; - - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - - ms.Position = 0; - - using (var wbassert = new XLWorkbook(ms)) - { - var wsassert = wbassert.Worksheet("BlankPivotTable"); - var ptassert = wsassert.PivotTable("pvtOptionsTest"); - Assert.AreNotEqual(null, ptassert, "name save failure"); - Assert.AreEqual("clmn header", ptassert.ColumnHeaderCaption, "ColumnHeaderCaption save failure"); - Assert.AreEqual("row header", ptassert.RowHeaderCaption, "RowHeaderCaption save failure"); - Assert.AreEqual(true, ptassert.MergeAndCenterWithLabels, "MergeAndCenterWithLabels save failure"); - Assert.AreEqual(12, ptassert.RowLabelIndent, "RowLabelIndent save failure"); - Assert.AreEqual(XLFilterAreaOrder.OverThenDown, ptassert.FilterAreaOrder, "FilterAreaOrder save failure"); - Assert.AreEqual(14, ptassert.FilterFieldsPageWrap, "FilterFieldsPageWrap save failure"); - Assert.AreEqual("error test", ptassert.ErrorValueReplacement, "ErrorValueReplacement save failure"); - Assert.AreEqual("empty test", ptassert.EmptyCellReplacement, "EmptyCellReplacement save failure"); - Assert.AreEqual(true, ptassert.AutofitColumns, "AutofitColumns save failure"); - Assert.AreEqual(false, ptassert.PreserveCellFormatting, "PreserveCellFormatting save failure"); - Assert.AreEqual(true, ptassert.ShowGrandTotalsRows, "ShowGrandTotalsRows save failure"); - Assert.AreEqual(true, ptassert.ShowGrandTotalsColumns, "ShowGrandTotalsColumns save failure"); - Assert.AreEqual(true, ptassert.FilteredItemsInSubtotals, "FilteredItemsInSubtotals save failure"); - Assert.AreEqual(false, ptassert.AllowMultipleFilters, "AllowMultipleFilters save failure"); - Assert.AreEqual(false, ptassert.UseCustomListsForSorting, "UseCustomListsForSorting save failure"); - Assert.AreEqual(false, ptassert.ShowExpandCollapseButtons, "ShowExpandCollapseButtons save failure"); - Assert.AreEqual(false, ptassert.ShowContextualTooltips, "ShowContextualTooltips save failure"); - Assert.AreEqual(false, ptassert.ShowPropertiesInTooltips, "ShowPropertiesInTooltips save failure"); - Assert.AreEqual(false, ptassert.DisplayCaptionsAndDropdowns, "DisplayCaptionsAndDropdowns save failure"); - Assert.AreEqual(true, ptassert.ClassicPivotTableLayout, "ClassicPivotTableLayout save failure"); - Assert.AreEqual(true, ptassert.ShowEmptyItemsOnRows, "ShowEmptyItemsOnRows save failure"); - Assert.AreEqual(true, ptassert.ShowEmptyItemsOnColumns, "ShowEmptyItemsOnColumns save failure"); - Assert.AreEqual(false, ptassert.DisplayItemLabels, "DisplayItemLabels save failure"); - Assert.AreEqual(true, ptassert.SortFieldsAtoZ, "SortFieldsAtoZ save failure"); - Assert.AreEqual(true, ptassert.PrintExpandCollapsedButtons, "PrintExpandCollapsedButtons save failure"); - Assert.AreEqual(true, ptassert.RepeatRowLabels, "RepeatRowLabels save failure"); - Assert.AreEqual(true, ptassert.PrintTitles, "PrintTitles save failure"); - Assert.AreEqual(false, ptassert.SaveSourceData, "SaveSourceData save failure"); - Assert.AreEqual(false, ptassert.EnableShowDetails, "EnableShowDetails save failure"); - // TODO Assert.AreEqual(false, ptassert.RefreshDataOnOpen, "RefreshDataOnOpen save failure"); - Assert.AreEqual(XLItemsToRetain.Max, ptassert.ItemsToRetainPerField, "ItemsToRetainPerField save failure"); - Assert.AreEqual(true, ptassert.EnableCellEditing, "EnableCellEditing save failure"); - Assert.AreEqual(XLPivotTableTheme.PivotStyleDark13, ptassert.Theme, "Theme save failure"); - Assert.AreEqual(true, ptassert.ShowValuesRow, "ShowValuesRow save failure"); - Assert.AreEqual(false, ptassert.ShowRowHeaders, "ShowRowHeaders save failure"); - Assert.AreEqual(false, ptassert.ShowColumnHeaders, "ShowColumnHeaders save failure"); - Assert.AreEqual(true, ptassert.ShowRowStripes, "ShowRowStripes save failure"); - Assert.AreEqual(true, ptassert.ShowColumnStripes, "ShowColumnStripes save failure"); - } - } - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PastrySalesData"); + var table = ws.Table("PastrySalesData"); + var ptSheet = wb.Worksheets.Add("BlankPivotTable"); + var pt = ptSheet.PivotTables.Add("pvtOptionsTest", ptSheet.Cell(1, 1), table); + + pt.ColumnHeaderCaption = "clmn header"; + pt.RowHeaderCaption = "row header"; + + pt.AutofitColumns = true; + pt.PreserveCellFormatting = false; + pt.ShowGrandTotalsColumns = true; + pt.ShowGrandTotalsRows = true; + pt.UseCustomListsForSorting = false; + pt.ShowExpandCollapseButtons = false; + pt.ShowContextualTooltips = false; + pt.DisplayCaptionsAndDropdowns = false; + pt.RepeatRowLabels = true; + pt.SaveSourceData = false; + pt.EnableShowDetails = false; + pt.ShowColumnHeaders = false; + pt.ShowRowHeaders = false; + + pt.MergeAndCenterWithLabels = true; // MergeItem + pt.RowLabelIndent = 12; // Indent + pt.FilterAreaOrder = XLFilterAreaOrder.OverThenDown; // PageOverThenDown + pt.FilterFieldsPageWrap = 14; // PageWrap + pt.ErrorValueReplacement = "error test"; // ErrorCaption + pt.EmptyCellReplacement = "empty test"; // MissingCaption + + pt.FilteredItemsInSubtotals = true; // Subtotal filtered page items + pt.AllowMultipleFilters = false; // MultipleFieldFilters + + pt.ShowPropertiesInTooltips = false; + pt.ClassicPivotTableLayout = true; + pt.ShowEmptyItemsOnRows = true; + pt.ShowEmptyItemsOnColumns = true; + pt.DisplayItemLabels = false; + pt.SortFieldsAtoZ = true; + + pt.PrintExpandCollapsedButtons = true; + pt.PrintTitles = true; + + // TODO pt.RefreshDataOnOpen = false; + pt.ItemsToRetainPerField = XLItemsToRetain.Max; + pt.EnableCellEditing = true; + pt.ShowValuesRow = true; + pt.ShowRowStripes = true; + pt.ShowColumnStripes = true; + pt.Theme = XLPivotTableTheme.PivotStyleDark13; + + pt.DataCaption = "Test Caption Values"; + pt.GrandTotalCaption = "Test Grand Total Caption"; + + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); + + ms.Position = 0; + + using var wbassert = new XLWorkbook(ms); + var wsassert = wbassert.Worksheet("BlankPivotTable"); + var ptassert = wsassert.PivotTable("pvtOptionsTest"); + Assert.AreNotEqual(null, ptassert, "name save failure"); + Assert.AreEqual("clmn header", ptassert.ColumnHeaderCaption, "ColumnHeaderCaption save failure"); + Assert.AreEqual("row header", ptassert.RowHeaderCaption, "RowHeaderCaption save failure"); + Assert.AreEqual(true, ptassert.MergeAndCenterWithLabels, "MergeAndCenterWithLabels save failure"); + Assert.AreEqual(12, ptassert.RowLabelIndent, "RowLabelIndent save failure"); + Assert.AreEqual(XLFilterAreaOrder.OverThenDown, ptassert.FilterAreaOrder, "FilterAreaOrder save failure"); + Assert.AreEqual(14, ptassert.FilterFieldsPageWrap, "FilterFieldsPageWrap save failure"); + Assert.AreEqual("error test", ptassert.ErrorValueReplacement, "ErrorValueReplacement save failure"); + Assert.AreEqual("empty test", ptassert.EmptyCellReplacement, "EmptyCellReplacement save failure"); + Assert.AreEqual(true, ptassert.AutofitColumns, "AutofitColumns save failure"); + Assert.AreEqual(false, ptassert.PreserveCellFormatting, "PreserveCellFormatting save failure"); + Assert.AreEqual(true, ptassert.ShowGrandTotalsRows, "ShowGrandTotalsRows save failure"); + Assert.AreEqual(true, ptassert.ShowGrandTotalsColumns, "ShowGrandTotalsColumns save failure"); + Assert.AreEqual(true, ptassert.FilteredItemsInSubtotals, "FilteredItemsInSubtotals save failure"); + Assert.AreEqual(false, ptassert.AllowMultipleFilters, "AllowMultipleFilters save failure"); + Assert.AreEqual(false, ptassert.UseCustomListsForSorting, "UseCustomListsForSorting save failure"); + Assert.AreEqual(false, ptassert.ShowExpandCollapseButtons, "ShowExpandCollapseButtons save failure"); + Assert.AreEqual(false, ptassert.ShowContextualTooltips, "ShowContextualTooltips save failure"); + Assert.AreEqual(false, ptassert.ShowPropertiesInTooltips, "ShowPropertiesInTooltips save failure"); + Assert.AreEqual(false, ptassert.DisplayCaptionsAndDropdowns, "DisplayCaptionsAndDropdowns save failure"); + Assert.AreEqual(true, ptassert.ClassicPivotTableLayout, "ClassicPivotTableLayout save failure"); + Assert.AreEqual(true, ptassert.ShowEmptyItemsOnRows, "ShowEmptyItemsOnRows save failure"); + Assert.AreEqual(true, ptassert.ShowEmptyItemsOnColumns, "ShowEmptyItemsOnColumns save failure"); + Assert.AreEqual(false, ptassert.DisplayItemLabels, "DisplayItemLabels save failure"); + Assert.AreEqual(true, ptassert.SortFieldsAtoZ, "SortFieldsAtoZ save failure"); + Assert.AreEqual(true, ptassert.PrintExpandCollapsedButtons, "PrintExpandCollapsedButtons save failure"); + Assert.AreEqual(true, ptassert.RepeatRowLabels, "RepeatRowLabels save failure"); + Assert.AreEqual(true, ptassert.PrintTitles, "PrintTitles save failure"); + Assert.AreEqual(false, ptassert.SaveSourceData, "SaveSourceData save failure"); + Assert.AreEqual(false, ptassert.EnableShowDetails, "EnableShowDetails save failure"); + // TODO Assert.AreEqual(false, ptassert.RefreshDataOnOpen, "RefreshDataOnOpen save failure"); + Assert.AreEqual(XLItemsToRetain.Max, ptassert.ItemsToRetainPerField, "ItemsToRetainPerField save failure"); + Assert.AreEqual(true, ptassert.EnableCellEditing, "EnableCellEditing save failure"); + Assert.AreEqual(XLPivotTableTheme.PivotStyleDark13, ptassert.Theme, "Theme save failure"); + Assert.AreEqual(true, ptassert.ShowValuesRow, "ShowValuesRow save failure"); + Assert.AreEqual(false, ptassert.ShowRowHeaders, "ShowRowHeaders save failure"); + Assert.AreEqual(false, ptassert.ShowColumnHeaders, "ShowColumnHeaders save failure"); + Assert.AreEqual(true, ptassert.ShowRowStripes, "ShowRowStripes save failure"); + Assert.AreEqual(true, ptassert.ShowColumnStripes, "ShowColumnStripes save failure"); + Assert.AreEqual("Test Caption Values", ptassert.DataCaption, "DataCaption save failure"); + Assert.AreEqual("Test Grand Total Caption", ptassert.GrandTotalCaption, "GrandTotalCaption save failure"); } - [TestCase(true)] - [TestCase(false)] - public void PivotFieldOptionsSaveTest(bool withDefaults) + [Test] + public void PivotTableOptionsSaveTest_CaptionsNotSet() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("PastrySalesData"); - var table = ws.Table("PastrySalesData"); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PastrySalesData"); + var table = ws.Table("PastrySalesData"); + var ptSheet = wb.Worksheets.Add("BlankPivotTable"); + var pt = ptSheet.PivotTables.Add("pvtOptionsTest", ptSheet.Cell(1, 1), table); - var ptSheet = wb.Worksheets.Add("pvtFieldOptionsTest"); - var pt = ptSheet.PivotTables.Add("pvtFieldOptionsTest", ptSheet.Cell(1, 1), table); + pt.DataCaption = null; + pt.GrandTotalCaption = null; - var field = pt.RowLabels.Add("Name") - .SetSubtotalCaption("Test caption") - .SetCustomName("Test name"); - SetFieldOptions(field, withDefaults); + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); - pt.ColumnLabels.Add("Month"); - pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + ms.Position = 0; - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); + using var wbassert = new XLWorkbook(ms); + var wsassert = wbassert.Worksheet("BlankPivotTable"); + var ptassert = wsassert.PivotTable("pvtOptionsTest"); - ms.Position = 0; + Assert.AreEqual("Values", ptassert.DataCaption, "DataCaption save failure"); + Assert.AreEqual(null, ptassert.GrandTotalCaption, "GrandTotalCaption save failure"); + } - using (var wbassert = new XLWorkbook(ms)) - { - var wsassert = wbassert.Worksheet("pvtFieldOptionsTest"); - var ptassert = wsassert.PivotTable("pvtFieldOptionsTest"); - var pfassert = ptassert.RowLabels.Get("Name"); - Assert.AreNotEqual(null, pfassert, "name save failure"); - Assert.AreEqual("Test caption", pfassert.SubtotalCaption, "SubtotalCaption save failure"); - Assert.AreEqual("Test name", pfassert.CustomName, "CustomName save failure"); - AssertFieldOptions(pfassert, withDefaults); - } - } - } + [TestCase(true)] + [TestCase(false)] + public void PivotFieldOptionsSaveTest(bool withDefaults) + { + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("PastrySalesData"); + var table = ws.Table("PastrySalesData"); + + var ptSheet = wb.Worksheets.Add("pvtFieldOptionsTest"); + var pt = ptSheet.PivotTables.Add("pvtFieldOptionsTest", ptSheet.Cell(1, 1), table); + + var field = pt.RowLabels.Add("Name") + .SetSubtotalCaption("Test caption") + .SetCustomName("Test name"); + SetFieldOptions(field, withDefaults); + + pt.ColumnLabels.Add("Month"); + pt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); + + ms.Position = 0; + + using var wbassert = new XLWorkbook(ms); + var wsassert = wbassert.Worksheet("pvtFieldOptionsTest"); + var ptassert = wsassert.PivotTable("pvtFieldOptionsTest"); + var pfassert = ptassert.RowLabels.Get("Name"); + Assert.AreNotEqual(null, pfassert, "name save failure"); + Assert.AreEqual("Test caption", pfassert.SubtotalCaption, "SubtotalCaption save failure"); + Assert.AreEqual("Test name", pfassert.CustomName, "CustomName save failure"); + AssertFieldOptions(pfassert, withDefaults); } [Test] public void PivotTableStyleFormatsTest() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) + using (var wbSource = new XLWorkbook(stream)) + using (var wbDestination = new XLWorkbook()) { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var wbSource = new XLWorkbook(stream)) - using (var wbDestination = new XLWorkbook()) - { - var ws = wbSource.Worksheet("PastrySalesData"); - wbDestination.AddWorksheet(ws); - ws = wbDestination.Worksheet("PastrySalesData"); + var ws = wbSource.Worksheet("PastrySalesData"); + wbDestination.AddWorksheet(ws); + ws = wbDestination.Worksheet("PastrySalesData"); - var table = ws.Table("PastrySalesData"); - var ptSheet = wbDestination.Worksheets.Add("PivotTableStyleFormats"); - var pt = ptSheet.PivotTables.Add("pvtStyleFormats", ptSheet.Cell(1, 1), table); - pt.Layout = XLPivotLayout.Tabular; + var table = ws.Table("PastrySalesData"); + var ptSheet = wbDestination.Worksheets.Add("PivotTableStyleFormats"); + var pt = ptSheet.PivotTables.Add("pvtStyleFormats", ptSheet.Cell(1, 1), table); + pt.Layout = XLPivotLayout.Tabular; - pt.SetSubtotals(XLPivotSubtotals.AtBottom); + pt.SetSubtotals(XLPivotSubtotals.AtBottom); - var monthPivotField = pt.ColumnLabels.Add("Month"); + var monthPivotField = pt.ColumnLabels.Add("Month"); - var namePivotField = pt.RowLabels.Add("Name") - .SetSubtotalCaption("Test caption") - .SetCustomName("Test name") - .AddSubtotal(XLSubtotalFunction.Sum); + var namePivotField = pt.RowLabels.Add("Name") + .SetSubtotalCaption("Test caption") + .SetCustomName("Test name") + .AddSubtotal(XLSubtotalFunction.Sum); - ptSheet.SetTabActive(); + ptSheet.SetTabActive(); - var numberOfOrdersPivotValue = pt.Values.Add("NumberOfOrders") - .SetSummaryFormula(XLPivotSummary.Sum); + var numberOfOrdersPivotValue = pt.Values.Add("NumberOfOrders") + .SetSummaryFormula(XLPivotSummary.Sum); - var qualityPivotValue = pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); + var qualityPivotValue = pt.Values.Add("Quality").SetSummaryFormula(XLPivotSummary.Sum); - pt.StyleFormats.RowGrandTotalFormats.ForElement(XLPivotStyleFormatElement.All).Style.Font.FontColor = XLColor.VenetianRed; + pt.StyleFormats.RowGrandTotalFormats.ForElement(XLPivotStyleFormatElement.All).Style.Font.FontColor = XLColor.VenetianRed; - namePivotField.StyleFormats.Subtotal.Style.Fill.BackgroundColor = XLColor.Blue; - monthPivotField.StyleFormats.Label.Style.Fill.BackgroundColor = XLColor.Amber; - monthPivotField.StyleFormats.Header.Style.Font.FontColor = XLColor.Yellow; - namePivotField.StyleFormats.DataValuesFormat - .AndWith(monthPivotField, v => v.ToString() == "May") - .ForValueField(numberOfOrdersPivotValue) - .Style.Font.FontColor = XLColor.Green; + namePivotField.StyleFormats.Subtotal.Style.Fill.BackgroundColor = XLColor.Blue; + monthPivotField.StyleFormats.Label.Style.Fill.BackgroundColor = XLColor.Amber; + monthPivotField.StyleFormats.Header.Style.Font.FontColor = XLColor.Yellow; + namePivotField.StyleFormats.DataValuesFormat + .AndWith(monthPivotField, v => v.ToString() == "May") + .ForValueField(numberOfOrdersPivotValue) + .Style.Font.FontColor = XLColor.Green; - wbDestination.SaveAs(ms); - } + wbDestination.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheet("PivotTableStyleFormats"); - var pt = ws.PivotTable("pvtStyleFormats").CastTo(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheet("PivotTableStyleFormats"); + var pt = ws.PivotTable("pvtStyleFormats").CastTo(); - Assert.AreEqual(0, pt.StyleFormats.ColumnGrandTotalFormats.Count()); + Assert.AreEqual(0, pt.StyleFormats.ColumnGrandTotalFormats.Count()); - Assert.NotNull(pt.StyleFormats.RowGrandTotalFormats); - Assert.AreEqual(1, pt.StyleFormats.RowGrandTotalFormats.Count()); - Assert.AreEqual(XLPivotStyleFormatElement.All, pt.StyleFormats.RowGrandTotalFormats.First().AppliesTo); - Assert.AreEqual(XLColor.VenetianRed, pt.StyleFormats.RowGrandTotalFormats.ForElement(XLPivotStyleFormatElement.All).Style.Font.FontColor); + Assert.NotNull(pt.StyleFormats.RowGrandTotalFormats); + Assert.AreEqual(1, pt.StyleFormats.RowGrandTotalFormats.Count()); + Assert.AreEqual(XLPivotStyleFormatElement.All, pt.StyleFormats.RowGrandTotalFormats.First().AppliesTo); + Assert.AreEqual(XLColor.VenetianRed, pt.StyleFormats.RowGrandTotalFormats.ForElement(XLPivotStyleFormatElement.All).Style.Font.FontColor); - var namePivotField = pt.RowLabels.Get("Name"); - var monthPivotField = pt.ColumnLabels.Get("Month"); - var numberOfOrdersPivotValue = pt.Values.Get("NumberOfOrders"); + var namePivotField = pt.RowLabels.Get("Name"); + var monthPivotField = pt.ColumnLabels.Get("Month"); + var numberOfOrdersPivotValue = pt.Values.Get("NumberOfOrders"); - Assert.AreEqual(XLStyle.Default, namePivotField.StyleFormats.Label.Style); - Assert.AreEqual(XLColor.Blue, namePivotField.StyleFormats.Subtotal.Style.Fill.BackgroundColor); + Assert.AreEqual(XLStyle.Default, namePivotField.StyleFormats.Label.Style); + Assert.AreEqual(XLColor.Blue, namePivotField.StyleFormats.Subtotal.Style.Fill.BackgroundColor); - Assert.AreEqual(XLStyle.Default, monthPivotField.StyleFormats.Subtotal.Style); - Assert.AreEqual(XLColor.Amber, monthPivotField.StyleFormats.Label.Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, monthPivotField.StyleFormats.Header.Style.Font.FontColor); + Assert.AreEqual(XLStyle.Default, monthPivotField.StyleFormats.Subtotal.Style); + Assert.AreEqual(XLColor.Amber, monthPivotField.StyleFormats.Label.Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, monthPivotField.StyleFormats.Header.Style.Font.FontColor); - var nameDataValuesFormat = namePivotField.StyleFormats.DataValuesFormat as XLPivotValueStyleFormat; - Assert.AreEqual(2, nameDataValuesFormat.FieldReferences.Count()); + var nameDataValuesFormat = namePivotField.StyleFormats.DataValuesFormat as XLPivotValueStyleFormat; + Assert.AreEqual(2, nameDataValuesFormat.FieldReferences.Count); - Assert.AreEqual(monthPivotField, nameDataValuesFormat.FieldReferences.First().CastTo().PivotField); + Assert.AreEqual(monthPivotField, nameDataValuesFormat.FieldReferences.First().CastTo().PivotField); - Assert.AreEqual(numberOfOrdersPivotValue.CustomName, nameDataValuesFormat.FieldReferences.Last().CastTo().Value); + Assert.AreEqual(numberOfOrdersPivotValue.CustomName, nameDataValuesFormat.FieldReferences.Last().CastTo().Value); - wb.Save(); - } + wb.Save(); } } [Test] public void CopyPivotTableTests() { - using (var ms = new MemoryStream()) - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws1 = wb.Worksheet("pvt1"); - var pt1 = ws1.PivotTables.First() as XLPivotTable; + using var ms = new MemoryStream(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var wb = new XLWorkbook(stream); + var ws1 = wb.Worksheet("pvt1"); + var pt1 = ws1.PivotTables.First() as XLPivotTable; - Assert.Throws(() => pt1.CopyTo(pt1.TargetCell)); + Assert.Throws(() => pt1.CopyTo(pt1.TargetCell)); - var pt2 = pt1.CopyTo(ws1.Cell("AB100")) as XLPivotTable; + var pt2 = pt1.CopyTo(ws1.Cell("AB100")) as XLPivotTable; - AssertPivotTablesAreEqual(pt1, pt2, compareName: false); + AssertPivotTablesAreEqual(pt1, pt2, compareName: false); - var ws2 = wb.AddWorksheet("Copy Of pvt1"); - AssertPivotTablesAreEqual(pt1, pt1.CopyTo(ws2.FirstCell()) as XLPivotTable, compareName: true); + var ws2 = wb.AddWorksheet("Copy Of pvt1"); + AssertPivotTablesAreEqual(pt1, pt1.CopyTo(ws2.FirstCell()) as XLPivotTable, compareName: true); - using (var wb2 = new XLWorkbook()) - { - wb.Worksheet("PastrySalesData").CopyTo(wb2); + using var wb2 = new XLWorkbook(); + wb.Worksheet("PastrySalesData").CopyTo(wb2); - AssertPivotTablesAreEqual(pt1, pt1.CopyTo(wb2.AddWorksheet("pvt").FirstCell()) as XLPivotTable, compareName: true); - } - } + AssertPivotTablesAreEqual(pt1, pt1.CopyTo(wb2.AddWorksheet("pvt").FirstCell()) as XLPivotTable, compareName: true); } - private void AssertPivotTablesAreEqual(XLPivotTable original, XLPivotTable copy, Boolean compareName) + private void AssertPivotTablesAreEqual(XLPivotTable original, XLPivotTable copy, bool compareName) { Assert.AreNotEqual(original.Guid, copy.Guid); Assert.AreEqual(compareName, original.Name.Equals(copy.Name)); @@ -350,14 +365,16 @@ public Pastry(string name, int? code, int numberOfOrders, double quality, string [Test] public void BlankPivotTableField() { - using (var ms = new MemoryStream()) + using var wb = new XLWorkbook(); + + var expectedFilePath = @"Other\PivotTableReferenceFiles\BlankPivotTableField\BlankPivotTableField.xlsx"; + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => + // Based on .\ClosedXML\ClosedXML.Examples\PivotTables\PivotTables.cs + // But with empty column for Month + var pastries = new List { - // Based on .\ClosedXML\ClosedXML.Examples\PivotTables\PivotTables.cs - // But with empty column for Month - var pastries = new List - { new Pastry("Croissant", 101, 150, 60.2, "", new DateTime(2016, 04, 21)), new Pastry("Croissant", 101, 250, 50.42, "", new DateTime(2016, 05, 03)), new Pastry("Croissant", 101, 134, 22.12, "", new DateTime(2016, 06, 24)), @@ -378,64 +395,78 @@ public void BlankPivotTableField() // For ContainsBlank and integer rows/columns test new Pastry("Scone", null, 255, 18.4, "", null), - }; + }; - var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("PastrySalesData"); + // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 + var table = sheet.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); + sheet.Cell("F11").Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; + sheet.Columns().AdjustToContents(); - var sheet = wb.Worksheets.Add("PastrySalesData"); - // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 - var table = sheet.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); - sheet.Cell("F11").Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; - sheet.Columns().AdjustToContents(); + IXLWorksheet ptSheet; + IXLPivotTable pt; - IXLWorksheet ptSheet; - IXLPivotTable pt; + for (var i = 1; i <= 5; i++) + { + // Add a new sheet for our pivot table + ptSheet = wb.Worksheets.Add("pvt" + i); + + // Create the pivot table, using the data from the "PastrySalesData" table + pt = ptSheet.PivotTables.Add("pvt" + i, ptSheet.Cell(1, 1), table); - for (var i = 1; i <= 5; i++) + if (i == 1 || i == 4 || i == 5) { - // Add a new sheet for our pivot table - ptSheet = wb.Worksheets.Add("pvt" + i); - - // Create the pivot table, using the data from the "PastrySalesData" table - pt = ptSheet.PivotTables.Add("pvt" + i, ptSheet.Cell(1, 1), table); - - if (i == 1 || i == 4 || i == 5) - pt.ColumnLabels.Add("Name"); - else if (i == 2 || i == 3) - pt.RowLabels.Add("Name"); - - if (i == 1 || i == 3) - pt.RowLabels.Add("Month"); - else if (i == 2 || i == 4) - pt.ColumnLabels.Add("Month"); - else if (i == 5) - pt.RowLabels.Add("BakeDate"); - - // The values in our table will come from the "NumberOfOrders" field - // The default calculation setting is a total of each row/column - pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") - .ShowAsPercentageFrom("Name").And("Bearclaw") - .NumberFormat.Format = "0%"; - - ptSheet.Columns().AdjustToContents(); + pt.ColumnLabels.Add("Name"); + } + else if (i == 2 || i == 3) + { + pt.RowLabels.Add("Name"); } - return wb; - }, @"Other\PivotTableReferenceFiles\BlankPivotTableField\BlankPivotTableField.xlsx"); - } + if (i == 1 || i == 3) + { + pt.RowLabels.Add("Month"); + } + else if (i == 2 || i == 4) + { + pt.ColumnLabels.Add("Month"); + } + else if (i == 5) + { + pt.RowLabels.Add("BakeDate"); + } + + // The values in our table will come from the "NumberOfOrders" field + // The default calculation setting is a total of each row/column + pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") + .ShowAsPercentageFrom("Name").And("Bearclaw") + .NumberFormat.Format = "0%"; + + ptSheet.Columns().AdjustToContents(); + } + + //Uncomment to replace expectation running.net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + + return wb; + }, expectedFilePath, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void SourceSheetWithWhitespace() { - using (var ms = new MemoryStream()) + using var wb = new XLWorkbook(); + + var expectedFilePath = @"Other\PivotTableReferenceFiles\SourceSheetWithWhitespace\outputfile.xlsx"; + + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => + // Based on .\ClosedXML\ClosedXML.Examples\PivotTables\PivotTables.cs + // But with empty column for Month + var pastries = new List { - // Based on .\ClosedXML\ClosedXML.Examples\PivotTables\PivotTables.cs - // But with empty column for Month - var pastries = new List - { new Pastry("Croissant", 101, 150, 60.2, "", new DateTime(2016, 04, 21)), new Pastry("Croissant", 101, 250, 50.42, "", new DateTime(2016, 05, 03)), new Pastry("Croissant", 101, 134, 22.12, "", new DateTime(2016, 06, 24)), @@ -456,53 +487,64 @@ public void SourceSheetWithWhitespace() // For ContainsBlank and integer rows/columns test new Pastry("Scone", null, 255, 18.4, "", null), - }; - - var wb = new XLWorkbook(); - - var sheet = wb.Worksheets.Add("Pastry Sales Data"); - // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 - var table = sheet.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); - sheet.Cell("F11").Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; - sheet.Columns().AdjustToContents(); - - IXLWorksheet ptSheet; - IXLPivotTable pt; - - // Add a new sheet for our pivot table - ptSheet = wb.Worksheets.Add("pvt"); - - // Create the pivot table, using the data from the "PastrySalesData" table - pt = ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table.AsRange()); - pt.ColumnLabels.Add("Name"); - pt.RowLabels.Add("Month"); - - // The values in our table will come from the "NumberOfOrders" field - // The default calculation setting is a total of each row/column - pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") - .ShowAsPercentageFrom("Name").And("Bearclaw") - .NumberFormat.Format = "0%"; - - ptSheet.Columns().AdjustToContents(); - - return wb; - }, @"Other\PivotTableReferenceFiles\SourceSheetWithWhitespace\outputfile.xlsx"); - } + }; + + var sheet = wb.Worksheets.Add("Pastry Sales Data"); + // Insert our list of pastry data into the "PastrySalesData" sheet at cell 1,1 + var table = sheet.Cell(1, 1).InsertTable(pastries, "PastrySalesData", true); + sheet.Cell("F11").Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center; + sheet.Columns().AdjustToContents(); + + IXLWorksheet ptSheet; + IXLPivotTable pt; + + // Add a new sheet for our pivot table + ptSheet = wb.Worksheets.Add("pvt"); + + // Create the pivot table, using the data from the "PastrySalesData" table + pt = ptSheet.PivotTables.Add("pvt", ptSheet.Cell(1, 1), table.AsRange()); + pt.ColumnLabels.Add("Name"); + pt.RowLabels.Add("Month"); + + // The values in our table will come from the "NumberOfOrders" field + // The default calculation setting is a total of each row/column + pt.Values.Add("NumberOfOrders", "NumberOfOrdersPercentageOfBearclaw") + .ShowAsPercentageFrom("Name").And("Bearclaw") + .NumberFormat.Format = "0%"; + + ptSheet.Columns().AdjustToContents(); + + // Uncomment to replace expectation running .net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + // Uncomment to replace expectation running .net4.8, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("ClosedXML.Tests", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + + return wb; + }, expectedFilePath, ignoreColumnFormats: !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); } [Test] public void PivotTableWithNoneTheme() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\PivotTableWithNoneTheme\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + var expectedFilePath = @"Other\PivotTableReferenceFiles\PivotTableWithNoneTheme\outputfile.xlsx"; + + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\PivotTableWithNoneTheme\inputfile.xlsx")); + using var ms = new MemoryStream(); + + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - wb.SaveAs(ms); - return wb; - }, @"Other\PivotTableReferenceFiles\PivotTableWithNoneTheme\outputfile.xlsx"); - } + var wb = new XLWorkbook(stream); + + wb.SaveAs(ms); + + // Uncomment to replace expectation running .net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + + return wb; + }, expectedFilePath); } [Test] @@ -691,88 +733,90 @@ public void MaintainPivotTableIntegrityOnMultipleSaves() new Pastry("Scone", null, 255, 18.4, "", null), }; - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("PastrySalesData"); - var table = ws.FirstCell().InsertTable(pastries, "PastrySalesData", true); + var ws = wb.Worksheets.Add("PastrySalesData"); + var table = ws.FirstCell().InsertTable(pastries, "PastrySalesData", true); - var pvtSheet = wb.Worksheets.Add("pvt"); - var pvt = table.CreatePivotTable(pvtSheet.FirstCell(), "PastryPvt"); + var pvtSheet = wb.Worksheets.Add("pvt"); + var pvt = table.CreatePivotTable(pvtSheet.FirstCell(), "PastryPvt"); - pvt.ColumnLabels.Add("Month"); - pvt.RowLabels.Add("Name"); - pvt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); + pvt.ColumnLabels.Add("Month"); + pvt.RowLabels.Add("Name"); + pvt.Values.Add("NumberOfOrders").SetSummaryFormula(XLPivotSummary.Sum); - //Deliberately try to save twice - wb.SaveAs(ms); - wb.SaveAs(ms); - } + //Deliberately try to save twice + wb.SaveAs(ms); + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual(1, wb.Worksheets.SelectMany(ws => ws.PivotTables).Count()); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual(1, wb.Worksheets.SelectMany(ws => ws.PivotTables).Count()); } } [Test] public void TwoPivotWithOneSourceTest() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\TwoPivotTablesWithSingleSource\input.xlsx"))) - TestHelper.CreateAndCompare(() => + var expectedFilePath = @"Other\PivotTableReferenceFiles\TwoPivotTablesWithSingleSource\output.xlsx"; + + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\TwoPivotTablesWithSingleSource\input.xlsx")); + TestHelper.CreateAndCompare(() => + { + var wb = new XLWorkbook(stream); + var srcRange = wb.Range("Sheet1!$B$2:$H$207"); + + foreach (var pt in wb.Worksheets.SelectMany(ws => ws.PivotTables)) { - var wb = new XLWorkbook(stream); - var srcRange = wb.Range("Sheet1!$B$2:$H$207"); + pt.SourceRange = srcRange; + } - foreach (var pt in wb.Worksheets.SelectMany(ws => ws.PivotTables)) - { - pt.SourceRange = srcRange; - } + //Uncomment to replace expectation running.net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); - return wb; - }, @"Other\PivotTableReferenceFiles\TwoPivotTablesWithSingleSource\output.xlsx"); + return wb; + }, expectedFilePath); } [Test] public void PivotSubtotalsLoadingTest() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\PivotSubtotalsSource\input.xlsx"))) - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - return wb; - }, @"Other\PivotTableReferenceFiles\PivotSubtotalsSource\input.xlsx"); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\PivotSubtotalsSource\input.xlsx")); + TestHelper.CreateAndCompare(() => + { + var wb = new XLWorkbook(stream); + return wb; + }, @"Other\PivotTableReferenceFiles\PivotSubtotalsSource\input.xlsx"); } [Test] public void ClearPivotTableTenderedTange() { // https://github.com/ClosedXML/ClosedXML/pull/856 - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\ClearPivotTableRenderedRangeWhenLoading\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\PivotTableReferenceFiles\ClearPivotTableRenderedRangeWhenLoading\inputfile.xlsx")); + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook(stream)) { - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("Sheet1"); - Assert.IsTrue(ws.Cell("B1").IsEmpty()); - Assert.IsTrue(ws.Cell("C2").IsEmpty()); - Assert.IsTrue(ws.Cell("D5").IsEmpty()); - wb.SaveAs(ms); - } + var ws = wb.Worksheet("Sheet1"); + Assert.IsTrue(ws.Cell("B1").IsEmpty()); + Assert.IsTrue(ws.Cell("C2").IsEmpty()); + Assert.IsTrue(ws.Cell("D5").IsEmpty()); + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheet("Sheet1"); - Assert.IsTrue(ws.Cell("B1").IsEmpty()); - Assert.IsTrue(ws.Cell("C2").IsEmpty()); - Assert.IsTrue(ws.Cell("D5").IsEmpty()); - } + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheet("Sheet1"); + Assert.IsTrue(ws.Cell("B1").IsEmpty()); + Assert.IsTrue(ws.Cell("C2").IsEmpty()); + Assert.IsTrue(ws.Cell("D5").IsEmpty()); } } @@ -802,4 +846,4 @@ private static void AssertFieldOptions(IXLPivotField field, bool withDefaults) Assert.AreEqual(withDefaults, field.IncludeNewItemsInFilter, "IncludeNewItemsInFilter save failure"); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Protection/XLSheetProtectionTests.cs b/ClosedXML.Tests/Excel/Protection/XLSheetProtectionTests.cs index 5a59ca87c..cc50839d6 100644 --- a/ClosedXML.Tests/Excel/Protection/XLSheetProtectionTests.cs +++ b/ClosedXML.Tests/Excel/Protection/XLSheetProtectionTests.cs @@ -6,7 +6,7 @@ using System.Linq; using static ClosedXML.Excel.XLProtectionAlgorithm; -namespace ClosedXML.Tests.Excel.Worksheets +namespace ClosedXML.Tests.Excel.Protection { [TestFixture] public class XLSheetProtectionTests @@ -20,7 +20,9 @@ public void AllowEverything() ws.Protect().AllowedElements = XLSheetProtectionElements.Everything; foreach (var element in Enum.GetValues(typeof(XLSheetProtectionElements)).Cast()) + { Assert.IsTrue(ws.Protection.AllowedElements.HasFlag(element), element.ToString()); + } } using (var wb = new XLWorkbook()) @@ -29,7 +31,9 @@ public void AllowEverything() ws.Protect().AllowElement(XLSheetProtectionElements.Everything); foreach (var element in Enum.GetValues(typeof(XLSheetProtectionElements)).Cast()) + { Assert.IsTrue(ws.Protection.AllowedElements.HasFlag(element), element.ToString()); + } } using (var wb = new XLWorkbook()) @@ -38,7 +42,9 @@ public void AllowEverything() ws.Protect().AllowEverything(); foreach (var element in Enum.GetValues(typeof(XLSheetProtectionElements)).Cast()) + { Assert.IsTrue(ws.Protection.AllowedElements.HasFlag(element), element.ToString()); + } } } @@ -53,8 +59,9 @@ public void AllowNothing() foreach (var element in Enum.GetValues(typeof(XLSheetProtectionElements)) .Cast() .Where(e => e != XLSheetProtectionElements.None)) - + { Assert.IsFalse(ws.Protection.AllowedElements.HasFlag(element), element.ToString()); + } } using (var wb = new XLWorkbook()) @@ -65,85 +72,84 @@ public void AllowNothing() foreach (var element in Enum.GetValues(typeof(XLSheetProtectionElements)) .Cast() .Where(e => e != XLSheetProtectionElements.None)) - + { Assert.IsFalse(ws.Protection.AllowedElements.HasFlag(element), element.ToString()); + } } } [Test] public void ChangeHashingAlgorithm() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - ws.Protect("123", Algorithm.SimpleHash); + var ws = wb.AddWorksheet(); + ws.Protect("123", Algorithm.SimpleHash); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.IsTrue(ws.Protection.IsProtected); - Assert.AreEqual(Algorithm.SimpleHash, ws.Protection.Algorithm); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.IsTrue(ws.Protection.IsProtected); + Assert.AreEqual(Algorithm.SimpleHash, ws.Protection.Algorithm); - ws.Unprotect("123"); - ws.Protect("123", Algorithm.SHA512); - wb.Save(); - } + ws.Unprotect("123"); + ws.Protect("123", Algorithm.SHA512); + wb.Save(); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.IsTrue(ws.Protection.IsProtected); - Assert.AreEqual(Algorithm.SHA512, ws.Protection.Algorithm); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.IsTrue(ws.Protection.IsProtected); + Assert.AreEqual(Algorithm.SHA512, ws.Protection.Algorithm); - Assert.DoesNotThrow(() => ws.Unprotect("123")); - } + Assert.DoesNotThrow(() => ws.Unprotect("123")); } } [Test] public void CopyProtectionFromAnotherSheet() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\SheetProtection.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws1 = wb.Worksheet("Protected Password = 123"); - var p1 = ws1.Protection.CastTo(); - Assert.IsTrue(p1.IsProtected); - - var ws2 = ws1.CopyTo("New worksheet"); - Assert.IsFalse(ws2.Protection.IsProtected); - var p2 = ws2.Protection.CopyFrom(p1).CastTo(); - - Assert.IsTrue(p2.IsProtected); - Assert.IsTrue(p2.IsPasswordProtected); - Assert.AreEqual(p1.Algorithm, p2.Algorithm); - Assert.AreEqual(p1.PasswordHash, p2.PasswordHash); - Assert.AreEqual(p1.Base64EncodedSalt, p2.Base64EncodedSalt); - Assert.AreEqual(p1.SpinCount, p2.SpinCount); - - Assert.IsTrue(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertColumns)); - Assert.IsTrue(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertRows)); - Assert.IsFalse(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertHyperlinks)); - - Assert.Throws(() => ws2.Unprotect()); - ws2.Unprotect("123"); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\SheetProtection.xlsx")); + using var wb = new XLWorkbook(stream); + var ws1 = wb.Worksheet("Protected Password = 123"); + var p1 = ws1.Protection.CastTo(); + Assert.IsTrue(p1.IsProtected); + + var ws2 = ws1.CopyTo("New worksheet"); + Assert.IsFalse(ws2.Protection.IsProtected); + var p2 = ws2.Protection.CopyFrom(p1).CastTo(); + + Assert.IsTrue(p2.IsProtected); + Assert.IsTrue(p2.IsPasswordProtected); + Assert.AreEqual(p1.Algorithm, p2.Algorithm); + Assert.AreEqual(p1.PasswordHash, p2.PasswordHash); + Assert.AreEqual(p1.Base64EncodedSalt, p2.Base64EncodedSalt); + Assert.AreEqual(p1.SpinCount, p2.SpinCount); + + Assert.IsTrue(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertColumns)); + Assert.IsTrue(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertRows)); + Assert.IsFalse(p2.AllowedElements.HasFlag(XLSheetProtectionElements.InsertHyperlinks)); + + Assert.Throws(() => ws2.Unprotect()); + ws2.Unprotect("123"); } [Test] public void SetWorksheetProtectionCloning() { - var ws1 = new XLWorkbook().AddWorksheet(); - var ws2 = new XLWorkbook().AddWorksheet(); + using var xLWorkbook1 = new XLWorkbook(); + var ws1 = xLWorkbook1.AddWorksheet(); + using var xLWorkbook2 = new XLWorkbook(); + var ws2 = xLWorkbook2.AddWorksheet(); ws1.Protect("123") .AllowElement(XLSheetProtectionElements.FormatEverything) @@ -162,32 +168,28 @@ public void SetWorksheetProtectionCloning() [Test] public void TestUnprotectWorksheetWithNoPassword() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SHA512PasswordProtection.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("Sheet1"); - Assert.IsTrue(ws.Protection.IsProtected); - ws.Unprotect(); - Assert.IsFalse(ws.Protection.IsProtected); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SHA512PasswordProtection.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("Sheet1"); + Assert.IsTrue(ws.Protection.IsProtected); + ws.Unprotect(); + Assert.IsFalse(ws.Protection.IsProtected); } [Test] public void TestWorksheetWithSHA512Protection() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SHA512PasswordProtection.xlsx"))) - using (var wb = new XLWorkbook(stream)) - { - var ws = wb.Worksheet("Sheet2"); - Assert.IsTrue(ws.Protection.IsProtected); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SHA512PasswordProtection.xlsx")); + using var wb = new XLWorkbook(stream); + var ws = wb.Worksheet("Sheet2"); + Assert.IsTrue(ws.Protection.IsProtected); - // Password required - Assert.Throws(() => ws.Unprotect()); + // Password required + Assert.Throws(() => ws.Unprotect()); - Assert.AreEqual(Algorithm.SHA512, ws.Protection.Algorithm); - ws.Unprotect("abc"); - Assert.IsFalse(ws.Protection.IsProtected); - } + Assert.AreEqual(Algorithm.SHA512, ws.Protection.Algorithm); + ws.Unprotect("abc"); + Assert.IsFalse(ws.Protection.IsProtected); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Protection/XLWorkbookProtectionTests.cs b/ClosedXML.Tests/Excel/Protection/XLWorkbookProtectionTests.cs index ac25c5aa3..e47b2ce8d 100644 --- a/ClosedXML.Tests/Excel/Protection/XLWorkbookProtectionTests.cs +++ b/ClosedXML.Tests/Excel/Protection/XLWorkbookProtectionTests.cs @@ -7,237 +7,219 @@ using System.Linq; using static ClosedXML.Excel.XLProtectionAlgorithm; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Protection { public class XLWorkbookProtectionTests { [Test] public void CanChangeProtectionAlgorithm() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var stream = GetProtectedWorkbookStreamWithPassword()) + using (var wb = new XLWorkbook(stream)) { - using (var stream = GetProtectedWorkbookStreamWithPassword()) - using (var wb = new XLWorkbook(stream)) - { - Assert.AreEqual(Algorithm.SHA512, wb.Protection.Algorithm); - wb.Unprotect("12345"); - wb.Protect("12345", Algorithm.SimpleHash); - - wb.SaveAs(ms); - } - - ms.Seek(0, SeekOrigin.Begin); - - using (var wb = new XLWorkbook(ms)) - { - Assert.IsTrue(wb.IsPasswordProtected); - Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); - } + Assert.AreEqual(Algorithm.SHA512, wb.Protection.Algorithm); + wb.Unprotect("12345"); + wb.Protect("12345", Algorithm.SimpleHash); + + wb.SaveAs(ms); + } + + ms.Seek(0, SeekOrigin.Begin); + + using (var wb = new XLWorkbook(ms)) + { + Assert.IsTrue(wb.IsPasswordProtected); + Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); } } [Test] public void CanChangeToPasswordProtected() { - using (var ms = new MemoryStream()) - { - using (var stream = GetProtectedWorkbookStreamWithoutPassword()) - using (var wb = new XLWorkbook(stream)) + using var ms = new MemoryStream(); + using (var stream = GetProtectedWorkbookStreamWithoutPassword()) + using (var wb = new XLWorkbook(stream)) - { - wb.Unprotect(); - wb.Protection.Protect("12345"); + { + wb.Unprotect(); + wb.Protection.Protect("12345"); - Assert.IsTrue(wb.Protection.IsPasswordProtected); + Assert.IsTrue(wb.Protection.IsPasswordProtected); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.IsTrue(wb.Protection.IsPasswordProtected); - Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); - Assert.AreNotEqual("", wb.Protection.PasswordHash); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.IsTrue(wb.Protection.IsPasswordProtected); + Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); + Assert.AreNotEqual("", wb.Protection.PasswordHash); } } [Test] public void CanChangeToProtectedWithoutPassword() { - using (var ms = new MemoryStream()) - { - using (var stream = GetProtectedWorkbookStreamWithPassword()) - using (var wb = new XLWorkbook(stream)) + using var ms = new MemoryStream(); + using (var stream = GetProtectedWorkbookStreamWithPassword()) + using (var wb = new XLWorkbook(stream)) - { - wb.Unprotect("12345"); - wb.Protection.Protect(); + { + wb.Unprotect("12345"); + wb.Protection.Protect(); - Assert.IsFalse(wb.Protection.IsPasswordProtected); - Assert.IsTrue(wb.Protection.IsProtected); + Assert.IsFalse(wb.Protection.IsPasswordProtected); + Assert.IsTrue(wb.Protection.IsProtected); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.IsFalse(wb.Protection.IsPasswordProtected); - Assert.IsTrue(wb.Protection.IsProtected); - Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); - Assert.AreEqual("", wb.Protection.PasswordHash); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.IsFalse(wb.Protection.IsPasswordProtected); + Assert.IsTrue(wb.Protection.IsProtected); + Assert.AreEqual(Algorithm.SimpleHash, wb.Protection.Algorithm); + Assert.AreEqual("", wb.Protection.PasswordHash); } } [Test] public void CannotUnprotectIfNoPassword() { - using (var stream = GetProtectedWorkbookStreamWithoutPassword()) - using (var wb = new XLWorkbook(stream)) - { - var ex = Assert.Throws(() => wb.Unprotect("dummy password")); - Assert.AreEqual("Invalid password", ex.Message); - } + using var stream = GetProtectedWorkbookStreamWithoutPassword(); + using var wb = new XLWorkbook(stream); + var ex = Assert.Throws(() => wb.Unprotect("dummy password")); + Assert.AreEqual("Invalid password", ex.Message); } [Test] public void CannotUnprotectWithoutPassword() { - using (var stream = GetProtectedWorkbookStreamWithPassword()) - using (var wb = new XLWorkbook(stream)) - { - var ex = Assert.Throws(() => wb.Unprotect()); - Assert.AreEqual("The workbook structure is password protected", ex.Message); - } + using var stream = GetProtectedWorkbookStreamWithPassword(); + using var wb = new XLWorkbook(stream); + var ex = Assert.Throws(() => wb.Unprotect()); + Assert.AreEqual("The workbook structure is password protected", ex.Message); } [Test] [Theory] public void CanProtectWithPassword(Algorithm algorithm) { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet(); + wb.AddWorksheet(); - Assert.IsFalse(wb.Protection.IsProtected); + Assert.IsFalse(wb.Protection.IsProtected); - wb.Protection.Protect("12345", algorithm); + wb.Protection.Protect("12345", algorithm); - wb.Protection.AllowNone(); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); + wb.Protection.AllowNone(); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.IsTrue(wb.Protection.IsPasswordProtected); - Assert.IsTrue(wb.Protection.IsProtected); + using (var wb = new XLWorkbook(ms)) + { + Assert.IsTrue(wb.Protection.IsPasswordProtected); + Assert.IsTrue(wb.Protection.IsProtected); - Assert.AreEqual(algorithm, wb.Protection.Algorithm); - Assert.AreNotEqual("", wb.Protection.PasswordHash); + Assert.AreEqual(algorithm, wb.Protection.Algorithm); + Assert.AreNotEqual("", wb.Protection.PasswordHash); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); - var ex = Assert.Throws(() => wb.Unprotect("dummy password")); - Assert.AreEqual("Invalid password", ex.Message); + var ex = Assert.Throws(() => wb.Unprotect("dummy password")); + Assert.AreEqual("Invalid password", ex.Message); - wb.Protection.Unprotect("12345"); + wb.Protection.Unprotect("12345"); - wb.Save(); - } + wb.Save(); } } [Test] public void CanUnprotectWithoutPassword() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var stream = GetProtectedWorkbookStreamWithoutPassword()) + using (var wb = new XLWorkbook(stream)) { - using (var stream = GetProtectedWorkbookStreamWithoutPassword()) - using (var wb = new XLWorkbook(stream)) - { - // Unprotect without password - wb.Unprotect(); + // Unprotect without password + wb.Unprotect(); - Assert.IsFalse(wb.Protection.IsProtected); + Assert.IsFalse(wb.Protection.IsProtected); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.IsFalse(wb.Protection.IsProtected); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.IsFalse(wb.Protection.IsProtected); } } [Test] public void CanUnprotectWithPassword() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var stream = GetProtectedWorkbookStreamWithPassword()) + using (var wb = new XLWorkbook(stream)) { - using (var stream = GetProtectedWorkbookStreamWithPassword()) - using (var wb = new XLWorkbook(stream)) - { - // Unprotect with password - wb.Unprotect("12345"); + // Unprotect with password + wb.Unprotect("12345"); - Assert.IsFalse(wb.Protection.IsProtected); + Assert.IsFalse(wb.Protection.IsProtected); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - Assert.IsFalse(wb.Protection.IsProtected); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.IsFalse(wb.Protection.IsProtected); } } [Test] public void CopyProtectionFromAnotherWorkbook() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\WorkbookProtection.xlsx"))) - using (var wb1 = new XLWorkbook(stream)) - using (var wb2 = new XLWorkbook()) - { - wb2.AddWorksheet(); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\Misc\WorkbookProtection.xlsx")); + using var wb1 = new XLWorkbook(stream); + using var wb2 = new XLWorkbook(); + wb2.AddWorksheet(); - var p1 = wb1.Protection.CastTo(); - Assert.IsTrue(p1.IsProtected); + var p1 = wb1.Protection.CastTo(); + Assert.IsTrue(p1.IsProtected); - Assert.IsFalse(wb2.Protection.IsProtected); - var p2 = wb2.Protection.CopyFrom(wb1.Protection).CastTo(); + Assert.IsFalse(wb2.Protection.IsProtected); + var p2 = wb2.Protection.CopyFrom(wb1.Protection).CastTo(); - Assert.IsTrue(p2.IsProtected); - Assert.IsTrue(p2.IsPasswordProtected); - Assert.AreEqual(p1.Algorithm, p2.Algorithm); - Assert.AreEqual(p1.PasswordHash, p2.PasswordHash); - Assert.AreEqual(p1.Base64EncodedSalt, p2.Base64EncodedSalt); - Assert.AreEqual(p1.SpinCount, p2.SpinCount); + Assert.IsTrue(p2.IsProtected); + Assert.IsTrue(p2.IsPasswordProtected); + Assert.AreEqual(p1.Algorithm, p2.Algorithm); + Assert.AreEqual(p1.PasswordHash, p2.PasswordHash); + Assert.AreEqual(p1.Base64EncodedSalt, p2.Base64EncodedSalt); + Assert.AreEqual(p1.SpinCount, p2.SpinCount); - Assert.IsTrue(p2.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); - Assert.IsFalse(p2.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); + Assert.IsTrue(p2.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); + Assert.IsFalse(p2.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); - Assert.Throws(() => wb2.Unprotect()); - wb2.Unprotect("Abc@123"); - } + Assert.Throws(() => wb2.Unprotect()); + wb2.Unprotect("Abc@123"); } [Test] @@ -273,35 +255,31 @@ public void IXLProtectableTests() [Test] public void LoadProtectionWithoutPasswordFromFile() { - using (var stream = GetProtectedWorkbookStreamWithoutPassword()) - using (var wb = new XLWorkbook(stream)) - { - Assert.IsFalse(wb.Protection.IsPasswordProtected); - Assert.IsTrue(wb.Protection.IsProtected); - Assert.AreEqual("", wb.Protection.PasswordHash); - Assert.IsTrue(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); - } + using var stream = GetProtectedWorkbookStreamWithoutPassword(); + using var wb = new XLWorkbook(stream); + Assert.IsFalse(wb.Protection.IsPasswordProtected); + Assert.IsTrue(wb.Protection.IsProtected); + Assert.AreEqual("", wb.Protection.PasswordHash); + Assert.IsTrue(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); } [Test] public void LoadProtectionWithPasswordFromFile() { - using (var stream = GetProtectedWorkbookStreamWithPassword()) - using (var wb = new XLWorkbook(stream)) - { - Assert.IsTrue(wb.Protection.IsPasswordProtected); - Assert.AreNotEqual("", wb.Protection.PasswordHash); - Assert.IsTrue(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); - Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); - } + using var stream = GetProtectedWorkbookStreamWithPassword(); + using var wb = new XLWorkbook(stream); + Assert.IsTrue(wb.Protection.IsPasswordProtected); + Assert.AreNotEqual("", wb.Protection.PasswordHash); + Assert.IsTrue(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows)); + Assert.IsFalse(wb.Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure)); } [Test] public void SetWorkbookProtectionCloning() { - var wb1 = new XLWorkbook(); - var wb2 = new XLWorkbook(); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); wb1.AddWorksheet(); wb2.AddWorksheet(); @@ -326,4 +304,4 @@ public void SetWorkbookProtectionCloning() private Stream GetProtectedWorkbookStreamWithPassword() => TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Protection\protectstructurewithpassword.xlsx")); } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/CopyingRangesTests.cs b/ClosedXML.Tests/Excel/Ranges/CopyingRangesTests.cs index 5f26edb8c..8d35300de 100644 --- a/ClosedXML.Tests/Excel/Ranges/CopyingRangesTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/CopyingRangesTests.cs @@ -1,9 +1,9 @@ using ClosedXML.Excel; using NUnit.Framework; -using System.Drawing; +using SkiaSharp; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Ranges { [TestFixture] public class CopyingRangesTests @@ -11,37 +11,37 @@ public class CopyingRangesTests [Test] public void CopyingColumns() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); - IXLColumn column1 = ws.Column(1); + var column1 = ws.Column(1); column1.Cell(1).Style.Fill.SetBackgroundColor(XLColor.Red); column1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.FromArgb(1, 1, 1)); column1.Cell(3).Style.Fill.SetBackgroundColor(XLColor.FromHtml("#CCCCCC")); column1.Cell(4).Style.Fill.SetBackgroundColor(XLColor.FromIndex(26)); - column1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromColor(Color.MediumSeaGreen)); + column1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromColor(SKColors.MediumSeaGreen)); column1.Cell(6).Style.Fill.SetBackgroundColor(XLColor.FromName("Blue")); column1.Cell(7).Style.Fill.SetBackgroundColor(XLColor.FromTheme(XLThemeColor.Accent3)); ws.Cell(1, 2).Value = column1; ws.Cell(1, 3).Value = column1.Column(1, 7); - IXLColumn column2 = ws.Column(2); + var column2 = ws.Column(2); Assert.AreEqual(XLColor.Red, column2.Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromArgb(1, 1, 1), column2.Cell(2).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), column2.Cell(3).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromIndex(26), column2.Cell(4).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.FromColor(Color.MediumSeaGreen), + Assert.AreEqual(XLColor.FromColor(SKColors.MediumSeaGreen), column2.Cell(5).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromName("Blue"), column2.Cell(6).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), column2.Cell(7).Style.Fill.BackgroundColor); - IXLColumn column3 = ws.Column(3); + var column3 = ws.Column(3); Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromArgb(1, 1, 1), column3.Cell(2).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), column3.Cell(3).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromIndex(26), column3.Cell(4).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.FromColor(Color.MediumSeaGreen), + Assert.AreEqual(XLColor.FromColor(SKColors.MediumSeaGreen), column3.Cell(5).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromName("Blue"), column3.Cell(6).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), column3.Cell(7).Style.Fill.BackgroundColor); @@ -50,30 +50,30 @@ public void CopyingColumns() [Test] public void CopyingRows() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); - IXLRow row1 = ws.Row(1); + var row1 = ws.Row(1); FillRow(row1); ws.Cell(2, 1).Value = row1; ws.Cell(3, 1).Value = row1.Row(1, 7); - IXLRow row2 = ws.Row(2); + var row2 = ws.Row(2); Assert.AreEqual(XLColor.Red, row2.Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row2.Cell(2).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row2.Cell(3).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromIndex(26), row2.Cell(4).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.FromColor(Color.MediumSeaGreen), row2.Cell(5).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.FromColor(SKColors.MediumSeaGreen), row2.Cell(5).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromName("Blue"), row2.Cell(6).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row2.Cell(7).Style.Fill.BackgroundColor); - IXLRow row3 = ws.Row(3); + var row3 = ws.Row(3); Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row3.Cell(2).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row3.Cell(3).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromIndex(26), row3.Cell(4).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.FromColor(Color.MediumSeaGreen), row3.Cell(5).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.FromColor(SKColors.MediumSeaGreen), row3.Cell(5).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromName("Blue"), row3.Cell(6).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row3.Cell(7).Style.Fill.BackgroundColor); @@ -86,8 +86,8 @@ public void CopyingRows() [Test] public void CopyingConditionalFormats() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); FillRow(ws.Row(1)); FillRow(ws.Row(2)); @@ -105,7 +105,7 @@ public void CopyingConditionalFormats() [Test] public void CopyingConditionalFormatsDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var format = ws1.Range("A1:J2").AddConditionalFormat(); @@ -142,11 +142,11 @@ private static void FillRow(IXLRow row1) row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.FromArgb(1, 1, 1)); row1.Cell(3).Style.Fill.SetBackgroundColor(XLColor.FromHtml("#CCCCCC")); row1.Cell(4).Style.Fill.SetBackgroundColor(XLColor.FromIndex(26)); - row1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromColor(Color.MediumSeaGreen)); + row1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromColor(SKColors.MediumSeaGreen)); row1.Cell(6).Style.Fill.SetBackgroundColor(XLColor.FromName("Blue")); row1.Cell(7).Style.Fill.SetBackgroundColor(XLColor.FromTheme(XLThemeColor.Accent3)); row1.Cell(2).AddConditionalFormat().WhenEquals("=" + row1.FirstCell().CellRight(6).Address.ToStringRelative()).Fill.SetBackgroundColor(XLColor.Blue); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/InsertingRangesTests.cs b/ClosedXML.Tests/Excel/Ranges/InsertingRangesTests.cs index 159b1bf53..171efd5b5 100644 --- a/ClosedXML.Tests/Excel/Ranges/InsertingRangesTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/InsertingRangesTests.cs @@ -1,9 +1,10 @@ using ClosedXML.Excel; +using ClosedXML.Excel.Ranges; using NUnit.Framework; using System; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Ranges { [TestFixture] public class InsertingRangesTests @@ -11,12 +12,12 @@ public class InsertingRangesTests [Test] public void InsertingColumnsPreservesFormatting() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); - IXLColumn column1 = ws.Column(1); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); + var column1 = ws.Column(1); column1.Style.Fill.SetBackgroundColor(XLColor.FrenchLilac); column1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.Fulvous); - IXLColumn column2 = ws.Column(2); + var column2 = ws.Column(2); column2.Style.Fill.SetBackgroundColor(XLColor.Xanadu); column2.Cell(2).Style.Fill.SetBackgroundColor(XLColor.MacaroniAndCheese); @@ -40,13 +41,13 @@ public void InsertingColumnsPreservesFormatting() [Test] public void InsertingRowsAbove() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); ws.Cell("B3").SetValue("X") .CellBelow().SetValue("B"); - IXLRangeRow r = ws.Range("B4").InsertRowsAbove(1).First(); + var r = ws.Range("B4").InsertRowsAbove(1).First(); r.Cell(1).SetValue("A"); Assert.AreEqual("X", ws.Cell("B3").GetString()); @@ -57,12 +58,12 @@ public void InsertingRowsAbove() [Test] public void InsertingRowsPreservesFormatting() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); - IXLRow row1 = ws.Row(1); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); + var row1 = ws.Row(1); row1.Style.Fill.SetBackgroundColor(XLColor.FrenchLilac); row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.Fulvous); - IXLRow row2 = ws.Row(2); + var row2 = ws.Row(2); row2.Style.Fill.SetBackgroundColor(XLColor.Xanadu); row2.Cell(2).Style.Fill.SetBackgroundColor(XLColor.MacaroniAndCheese); @@ -86,7 +87,7 @@ public void InsertingRowsPreservesFormatting() [Test] public void InsertingRowsPreservesComments() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("Insert Below"); @@ -100,7 +101,7 @@ public void InsertingRowsPreservesComments() [Test] public void InsertingColumnsPreservesComments() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); ws.Cell("A1").SetValue("Insert to the right"); @@ -131,33 +132,29 @@ public void InsertingColumnsPreservesComments() [TestCase("B1:B8", "A1:C4", -1, "B1:B8")] // More rows, shift left public void ShiftColumnsValid(string thisRangeAddress, string shiftedRangeAddress, int shiftedColumns, string expectedRange) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - var thisRange = ws.Range(thisRangeAddress) as XLRange; - var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var thisRange = ws.Range(thisRangeAddress) as XLRange; + var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; - thisRange.WorksheetRangeShiftedColumns(shiftedRange, shiftedColumns); + thisRange.WorksheetRangeShiftedColumns(shiftedRange, shiftedColumns); - Assert.IsTrue(thisRange.RangeAddress.IsValid); - Assert.AreEqual(expectedRange, thisRange.RangeAddress.ToString()); - } + Assert.IsTrue(thisRange.RangeAddress.IsValid); + Assert.AreEqual(expectedRange, thisRange.RangeAddress.ToString()); } [Test] [TestCase("B1:B4", "A1:C4", -2)] // Shift left too much public void ShiftColumnsInvalid(string thisRangeAddress, string shiftedRangeAddress, int shiftedColumns) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - var thisRange = ws.Range(thisRangeAddress) as XLRange; - var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var thisRange = ws.Range(thisRangeAddress) as XLRange; + var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; - thisRange.WorksheetRangeShiftedColumns(shiftedRange, shiftedColumns); + thisRange.WorksheetRangeShiftedColumns(shiftedRange, shiftedColumns); - Assert.IsFalse(thisRange.RangeAddress.IsValid); - } + Assert.IsFalse(thisRange.RangeAddress.IsValid); } [Test] @@ -181,39 +178,35 @@ public void ShiftColumnsInvalid(string thisRangeAddress, string shiftedRangeAddr [TestCase("A2:D2", "A1:C4", -1, "A2:D2")] // More columns, shift up public void ShiftRowsValid(string thisRangeAddress, string shiftedRangeAddress, int shiftedRows, string expectedRange) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - var thisRange = ws.Range(thisRangeAddress) as XLRange; - var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var thisRange = ws.Range(thisRangeAddress) as XLRange; + var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; - thisRange.WorksheetRangeShiftedRows(shiftedRange, shiftedRows); + thisRange.WorksheetRangeShiftedRows(shiftedRange, shiftedRows); - Assert.IsTrue(thisRange.RangeAddress.IsValid); - Assert.AreEqual(expectedRange, thisRange.RangeAddress.ToString()); - } + Assert.IsTrue(thisRange.RangeAddress.IsValid); + Assert.AreEqual(expectedRange, thisRange.RangeAddress.ToString()); } [Test] [TestCase("A2:C2", "A1:C4", -2)] // Shift up too much public void ShiftRowsInvalid(string thisRangeAddress, string shiftedRangeAddress, int shiftedRows) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - var thisRange = ws.Range(thisRangeAddress) as XLRange; - var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var thisRange = ws.Range(thisRangeAddress) as XLRange; + var shiftedRange = ws.Range(shiftedRangeAddress) as XLRange; - thisRange.WorksheetRangeShiftedRows(shiftedRange, shiftedRows); + thisRange.WorksheetRangeShiftedRows(shiftedRange, shiftedRows); - Assert.IsFalse(thisRange.RangeAddress.IsValid); - } + Assert.IsFalse(thisRange.RangeAddress.IsValid); } [Test] public void InsertZeroColumnsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsAfter(0)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsBefore(0)); @@ -222,7 +215,7 @@ public void InsertZeroColumnsFails() [Test] public void InsertNegativeNumberOfColumnsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsAfter(-1)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsBefore(-1)); @@ -231,7 +224,7 @@ public void InsertNegativeNumberOfColumnsFails() [Test] public void InsertTooLargeNumberOfColumnsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsAfter(16385)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertColumnsBefore(16385)); @@ -240,7 +233,7 @@ public void InsertTooLargeNumberOfColumnsFails() [Test] public void InsertZeroRowsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsAbove(0)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsBelow(0)); @@ -249,7 +242,7 @@ public void InsertZeroRowsFails() [Test] public void InsertNegativeNumberOfRowsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsAbove(-1)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsBelow(-1)); @@ -258,7 +251,7 @@ public void InsertNegativeNumberOfRowsFails() [Test] public void InsertTooLargeNumberOrRowsFails() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var range = ws.FirstCell().AsRange(); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsAbove(1048577)); Assert.Throws(typeof(ArgumentOutOfRangeException), () => range.InsertRowsBelow(1048577)); @@ -268,31 +261,29 @@ public void InsertTooLargeNumberOrRowsFails() public void MergedRangesConsistencyWhenInsertingRows() { // https://github.com/ClosedXML/ClosedXML/issues/1013 - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - //create merged row - ws.Cell("A1").Value = "Merged Row(1) of Range (A1:F1)"; - ws.Range("A1:F1").Row(1).Merge(); + //create merged row + ws.Cell("A1").Value = "Merged Row(1) of Range (A1:F1)"; + ws.Range("A1:F1").Row(1).Merge(); - var row = ws.FirstRow(); + var row = ws.FirstRow(); - // Add some lines and copy format & merging - for (var r = 1; r <= 10; r++) - { - row.InsertRowsBelow(1); // insert a row below row 1, as a row 2 - row.CopyTo(row.RowBelow()); // copy format and merging from row 1 to row 2 + // Add some lines and copy format & merging + for (var r = 1; r <= 10; r++) + { + row.InsertRowsBelow(1); // insert a row below row 1, as a row 2 + row.CopyTo(row.RowBelow()); // copy format and merging from row 1 to row 2 - var duplicates = ws.MergedRanges - .GroupBy(s => s.ToString()) - .Where(g => g.Count() > 1) - .Select(y => new { Element = y.Key, Counter = y.Count() }) - .ToList(); + var duplicates = ws.MergedRanges + .GroupBy(s => s.ToString()) + .Where(g => g.Count() > 1) + .Select(y => new { Element = y.Key, Counter = y.Count() }) + .ToList(); - Assert.AreEqual(0, duplicates.Count); - } + Assert.AreEqual(0, duplicates.Count); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/MergedRangesTests.cs b/ClosedXML.Tests/Excel/Ranges/MergedRangesTests.cs index 81fc3346c..e4dee6382 100644 --- a/ClosedXML.Tests/Excel/Ranges/MergedRangesTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/MergedRangesTests.cs @@ -2,7 +2,7 @@ using NUnit.Framework; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Ranges { [TestFixture] public class MergedRangesTests @@ -10,12 +10,12 @@ public class MergedRangesTests [Test] public void LastCellFromMerge() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet"); ws.Range("B2:D4").Merge(); - string first = ws.FirstCellUsed(XLCellsUsedOptions.All).Address.ToStringRelative(); - string last = ws.LastCellUsed(XLCellsUsedOptions.All).Address.ToStringRelative(); + var first = ws.FirstCellUsed(XLCellsUsedOptions.All).Address.ToStringRelative(); + var last = ws.LastCellUsed(XLCellsUsedOptions.All).Address.ToStringRelative(); Assert.AreEqual("B2", first); Assert.AreEqual("D4", last); @@ -28,18 +28,16 @@ public void LastCellFromMerge() [TestCase("C7:D7", "E7:F7")] public void MergedRangesShiftedOnColumnInsert(string originalRange, string expectedRange) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - var range = ws.Range(originalRange).Merge(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + var range = ws.Range(originalRange).Merge(); - ws.Column(2).InsertColumnsAfter(2); + ws.Column(2).InsertColumnsAfter(2); - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(1, mr.Length); - Assert.AreSame(range, mr.Single()); - Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); - } + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(1, mr.Length); + Assert.AreSame(range, mr.Single()); + Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); } [TestCase("A1:B1", "A1:B1")] @@ -49,18 +47,16 @@ public void MergedRangesShiftedOnColumnInsert(string originalRange, string expec [TestCase("G4:G5", "G6:G7")] public void MergedRangesShiftedOnRowInsert(string originalRange, string expectedRange) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - var range = ws.Range(originalRange).Merge(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + var range = ws.Range(originalRange).Merge(); - ws.Row(2).InsertRowsBelow(2); + ws.Row(2).InsertRowsBelow(2); - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(1, mr.Length); - Assert.AreSame(range, mr.Single()); - Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); - } + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(1, mr.Length); + Assert.AreSame(range, mr.Single()); + Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); } [TestCase("A1:A2", true, "A1:A2")] @@ -70,25 +66,23 @@ public void MergedRangesShiftedOnRowInsert(string originalRange, string expected [TestCase("C7:D7", true, "B7:C7")] public void MergedRangesShiftedOnColumnDelete(string originalRange, bool expectedExist, string expectedRange) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + var range = ws.Range(originalRange).Merge(); + + ws.Column(2).Delete(); + + var mr = ws.MergedRanges.ToArray(); + if (expectedExist) { - var ws = wb.AddWorksheet("MRShift"); - var range = ws.Range(originalRange).Merge(); - - ws.Column(2).Delete(); - - var mr = ws.MergedRanges.ToArray(); - if (expectedExist) - { - Assert.AreEqual(1, mr.Length); - Assert.AreSame(range, mr.Single()); - Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); - } - else - { - Assert.AreEqual(0, mr.Length); - Assert.IsFalse(range.RangeAddress.IsValid); - } + Assert.AreEqual(1, mr.Length); + Assert.AreSame(range, mr.Single()); + Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); + } + else + { + Assert.AreEqual(0, mr.Length); + Assert.IsFalse(range.RangeAddress.IsValid); } } @@ -99,261 +93,241 @@ public void MergedRangesShiftedOnColumnDelete(string originalRange, bool expecte [TestCase("G4:G5", true, "G3:G4")] public void MergedRangesShiftedOnRowDelete(string originalRange, bool expectedExist, string expectedRange) { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + var range = ws.Range(originalRange).Merge(); + + ws.Row(2).Delete(); + + var mr = ws.MergedRanges.ToArray(); + if (expectedExist) + { + Assert.AreEqual(1, mr.Length); + Assert.AreSame(range, mr.Single()); + Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); + } + else { - var ws = wb.AddWorksheet("MRShift"); - var range = ws.Range(originalRange).Merge(); - - ws.Row(2).Delete(); - - var mr = ws.MergedRanges.ToArray(); - if (expectedExist) - { - Assert.AreEqual(1, mr.Length); - Assert.AreSame(range, mr.Single()); - Assert.AreEqual(expectedRange, range.RangeAddress.ToString()); - } - else - { - Assert.AreEqual(0, mr.Length); - Assert.IsFalse(range.RangeAddress.IsValid); - } + Assert.AreEqual(0, mr.Length); + Assert.IsFalse(range.RangeAddress.IsValid); } } [Test] public void ShiftRangeRightBreaksMerges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - ws.Range("B2:C3").Merge(); - ws.Range("B4:C5").Merge(); - ws.Range("F2:G3").Merge(); // to be broken - ws.Range("F4:G5").Merge(); // to be broken - ws.Range("H1:I2").Merge(); - ws.Range("H5:I6").Merge(); - - ws.Range("D3:E4").InsertColumnsAfter(2); - - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(4, mr.Length); - Assert.AreEqual("H1:I2", mr[0].RangeAddress.ToString()); - Assert.AreEqual("B2:C3", mr[1].RangeAddress.ToString()); - Assert.AreEqual("B4:C5", mr[2].RangeAddress.ToString()); - Assert.AreEqual("H5:I6", mr[3].RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + ws.Range("B2:C3").Merge(); + ws.Range("B4:C5").Merge(); + ws.Range("F2:G3").Merge(); // to be broken + ws.Range("F4:G5").Merge(); // to be broken + ws.Range("H1:I2").Merge(); + ws.Range("H5:I6").Merge(); + + ws.Range("D3:E4").InsertColumnsAfter(2); + + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(4, mr.Length); + Assert.AreEqual("H1:I2", mr[0].RangeAddress.ToString()); + Assert.AreEqual("B2:C3", mr[1].RangeAddress.ToString()); + Assert.AreEqual("B4:C5", mr[2].RangeAddress.ToString()); + Assert.AreEqual("H5:I6", mr[3].RangeAddress.ToString()); } [Test] public void ShiftRangeLeftBreaksMerges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - ws.Range("B2:C3").Merge(); - ws.Range("B4:C5").Merge(); - ws.Range("F2:G3").Merge(); // to be broken - ws.Range("F4:G5").Merge(); // to be broken - ws.Range("H1:I2").Merge(); - ws.Range("H5:I6").Merge(); - - ws.Range("D3:E4").Delete(XLShiftDeletedCells.ShiftCellsLeft); - - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(4, mr.Length); - Assert.AreEqual("H1:I2", mr[0].RangeAddress.ToString()); - Assert.AreEqual("B2:C3", mr[1].RangeAddress.ToString()); - Assert.AreEqual("B4:C5", mr[2].RangeAddress.ToString()); - Assert.AreEqual("H5:I6", mr[3].RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + ws.Range("B2:C3").Merge(); + ws.Range("B4:C5").Merge(); + ws.Range("F2:G3").Merge(); // to be broken + ws.Range("F4:G5").Merge(); // to be broken + ws.Range("H1:I2").Merge(); + ws.Range("H5:I6").Merge(); + + ws.Range("D3:E4").Delete(XLShiftDeletedCells.ShiftCellsLeft); + + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(4, mr.Length); + Assert.AreEqual("H1:I2", mr[0].RangeAddress.ToString()); + Assert.AreEqual("B2:C3", mr[1].RangeAddress.ToString()); + Assert.AreEqual("B4:C5", mr[2].RangeAddress.ToString()); + Assert.AreEqual("H5:I6", mr[3].RangeAddress.ToString()); } [Test] public void RangeShiftDownBreaksMerges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - ws.Range("B2:C3").Merge(); - ws.Range("D2:E3").Merge(); - ws.Range("B6:C7").Merge(); // to be broken - ws.Range("D6:E7").Merge(); // to be broken - ws.Range("A8:B9").Merge(); - ws.Range("E8:F9").Merge(); - - ws.Range("C4:D5").InsertRowsBelow(2); - - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(4, mr.Length); - Assert.AreEqual("B2:C3", mr[0].RangeAddress.ToString()); - Assert.AreEqual("D2:E3", mr[1].RangeAddress.ToString()); - Assert.AreEqual("A8:B9", mr[2].RangeAddress.ToString()); - Assert.AreEqual("E8:F9", mr[3].RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + ws.Range("B2:C3").Merge(); + ws.Range("D2:E3").Merge(); + ws.Range("B6:C7").Merge(); // to be broken + ws.Range("D6:E7").Merge(); // to be broken + ws.Range("A8:B9").Merge(); + ws.Range("E8:F9").Merge(); + + ws.Range("C4:D5").InsertRowsBelow(2); + + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(4, mr.Length); + Assert.AreEqual("B2:C3", mr[0].RangeAddress.ToString()); + Assert.AreEqual("D2:E3", mr[1].RangeAddress.ToString()); + Assert.AreEqual("A8:B9", mr[2].RangeAddress.ToString()); + Assert.AreEqual("E8:F9", mr[3].RangeAddress.ToString()); } [Test] public void RangeShiftUpBreaksMerges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("MRShift"); - ws.Range("B2:C3").Merge(); - ws.Range("D2:E3").Merge(); - ws.Range("B6:C7").Merge(); // to be broken - ws.Range("D6:E7").Merge(); // to be broken - ws.Range("A8:B9").Merge(); - ws.Range("E8:F9").Merge(); - - ws.Range("C4:D5").Delete(XLShiftDeletedCells.ShiftCellsUp); - - var mr = ws.MergedRanges.ToArray(); - Assert.AreEqual(4, mr.Length); - Assert.AreEqual("B2:C3", mr[0].RangeAddress.ToString()); - Assert.AreEqual("D2:E3", mr[1].RangeAddress.ToString()); - Assert.AreEqual("A8:B9", mr[2].RangeAddress.ToString()); - Assert.AreEqual("E8:F9", mr[3].RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("MRShift"); + ws.Range("B2:C3").Merge(); + ws.Range("D2:E3").Merge(); + ws.Range("B6:C7").Merge(); // to be broken + ws.Range("D6:E7").Merge(); // to be broken + ws.Range("A8:B9").Merge(); + ws.Range("E8:F9").Merge(); + + ws.Range("C4:D5").Delete(XLShiftDeletedCells.ShiftCellsUp); + + var mr = ws.MergedRanges.ToArray(); + Assert.AreEqual(4, mr.Length); + Assert.AreEqual("B2:C3", mr[0].RangeAddress.ToString()); + Assert.AreEqual("D2:E3", mr[1].RangeAddress.ToString()); + Assert.AreEqual("A8:B9", mr[2].RangeAddress.ToString()); + Assert.AreEqual("E8:F9", mr[3].RangeAddress.ToString()); } [Test] public void MergedCellsAcquireFirstCellStyle() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; - ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; - ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; - ws.Range("A1:A3").Merge(); - - Assert.AreEqual(XLColor.Red, ws.Cell("A1").Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Cell("A2").Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Cell("A3").Style.Fill.BackgroundColor); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; + ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; + ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; + ws.Range("A1:A3").Merge(); + + Assert.AreEqual(XLColor.Red, ws.Cell("A1").Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Cell("A2").Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Cell("A3").Style.Fill.BackgroundColor); } [Test] public void MergedCellsLooseData() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Range("A1:A3").SetValue(100); - ws.Range("A1:A3").Merge(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Range("A1:A3").SetValue(100); + ws.Range("A1:A3").Merge(); - Assert.AreEqual(100, ws.Cell("A1").Value); - Assert.AreEqual("", ws.Cell("A2").Value); - Assert.AreEqual("", ws.Cell("A3").Value); - } + Assert.AreEqual(100, ws.Cell("A1").Value); + Assert.AreEqual("", ws.Cell("A2").Value); + Assert.AreEqual("", ws.Cell("A3").Value); } [Test] public void MergedCellsLooseConditionalFormats() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").AddConditionalFormat().WhenContains("1").Fill.BackgroundColor = XLColor.Red; - ws.Cell("A2").AddConditionalFormat().WhenContains("2").Fill.BackgroundColor = XLColor.Yellow; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").AddConditionalFormat().WhenContains("1").Fill.BackgroundColor = XLColor.Red; + ws.Cell("A2").AddConditionalFormat().WhenContains("2").Fill.BackgroundColor = XLColor.Yellow; - ws.Range("A1:A2").Merge(); + ws.Range("A1:A2").Merge(); - Assert.AreEqual(1, ws.ConditionalFormats.Count()); - Assert.AreEqual("A1:A1", ws.ConditionalFormats.Single().Ranges.Single().RangeAddress.ToString()); - } + Assert.AreEqual(1, ws.ConditionalFormats.Count()); + Assert.AreEqual("A1:A1", ws.ConditionalFormats.Single().Ranges.Single().RangeAddress.ToString()); } [Test] public void MergedCellsLooseDataValidation() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").CreateDataValidation().WholeNumber.Between(1, 2); - ws.Cell("A2").CreateDataValidation().Date.GreaterThan(new System.DateTime(2018, 1, 1)); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").CreateDataValidation().WholeNumber.Between(1, 2); + ws.Cell("A2").CreateDataValidation().Date.GreaterThan(new System.DateTime(2018, 1, 1)); - ws.Range("A1:A2").Merge(); + ws.Range("A1:A2").Merge(); - Assert.IsTrue(ws.Cell("A1").HasDataValidation); - Assert.AreEqual("1", ws.Cell("A1").GetDataValidation().MinValue); - Assert.AreEqual("2", ws.Cell("A1").GetDataValidation().MaxValue); - Assert.IsFalse(ws.Cell("A2").HasDataValidation); - } + Assert.IsTrue(ws.Cell("A1").HasDataValidation); + Assert.AreEqual("1", ws.Cell("A1").GetDataValidation().MinValue); + Assert.AreEqual("2", ws.Cell("A1").GetDataValidation().MaxValue); + Assert.IsFalse(ws.Cell("A2").HasDataValidation); } [Test] public void UnmergedCellsPreserveStyle() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var range = ws.Range("B2:D4"); - range.Style.Fill.SetBackgroundColor(XLColor.Yellow); - range.Style.Border.SetOutsideBorder(XLBorderStyleValues.Thick) - .Border.SetOutsideBorderColor(XLColor.DarkBlue) - .Border.SetInsideBorder(XLBorderStyleValues.Thin) - .Border.SetInsideBorderColor(XLColor.Pink); - range.Cells().ForEach(c => c.Value = c.Address.ToString()); - - var firstCell = ws.Cell("B2"); - firstCell.Style.Fill.SetBackgroundColor(XLColor.Red) - .Alignment.SetHorizontal(XLAlignmentHorizontalValues.Center) - .Font.SetBold(); - - range.Merge(); - range.Unmerge(); - - Assert.IsTrue(range.Cells().All(c => c.Style.Fill.BackgroundColor == XLColor.Red)); - Assert.IsTrue(range.Cells().Where(c => c != firstCell).All(c => c.GetString().Length == 0)); - Assert.AreEqual("B2", firstCell.Value); - - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B2").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B2").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("C2").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D2").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D2").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D2").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D2").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B3").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D3").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B4").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B4").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B4").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B4").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("C4").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D4").Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D4").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D4").Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D4").Style.Border.LeftBorder); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var range = ws.Range("B2:D4"); + range.Style.Fill.SetBackgroundColor(XLColor.Yellow); + range.Style.Border.SetOutsideBorder(XLBorderStyleValues.Thick) + .Border.SetOutsideBorderColor(XLColor.DarkBlue) + .Border.SetInsideBorder(XLBorderStyleValues.Thin) + .Border.SetInsideBorderColor(XLColor.Pink); + range.Cells().ForEach(c => c.Value = c.Address.ToString()); + + var firstCell = ws.Cell("B2"); + firstCell.Style.Fill.SetBackgroundColor(XLColor.Red) + .Alignment.SetHorizontal(XLAlignmentHorizontalValues.Center) + .Font.SetBold(); + + range.Merge(); + range.Unmerge(); + + Assert.IsTrue(range.Cells().All(c => c.Style.Fill.BackgroundColor == XLColor.Red)); + Assert.IsTrue(range.Cells().Where(c => c != firstCell).All(c => c.GetString().Length == 0)); + Assert.AreEqual("B2", firstCell.Value); + + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B2").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B2").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("C2").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D2").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D2").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D2").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D2").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B3").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B3").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C3").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D3").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D3").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B4").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B4").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B4").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("B4").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("C4").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C4").Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D4").Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D4").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, ws.Cell("D4").Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("D4").Style.Border.LeftBorder); } [Test] @@ -440,4 +414,4 @@ public void MergeSingleCellRangeDoesNothing() Assert.AreEqual(0, ws.MergedRanges.Count); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/RangeIndexTest.cs b/ClosedXML.Tests/Excel/Ranges/RangeIndexTest.cs index cf1067e17..44d2197d5 100644 --- a/ClosedXML.Tests/Excel/Ranges/RangeIndexTest.cs +++ b/ClosedXML.Tests/Excel/Ranges/RangeIndexTest.cs @@ -15,18 +15,16 @@ public class RangeIndexTest [Test] public void FindExistingMatches() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - for (int i = 1; i <= TEST_COUNT; i++) + for (var i = 1; i <= TEST_COUNT; i++) + { + for (var j = 2; j <= 4; j++) { - for (int j = 2; j <= 4; j++) - { - var address = new XLAddress(ws, i * 2, j, false, false); - Assert.True(index.Contains(in address)); - } + var address = new XLAddress(ws, i * 2, j, false, false); + Assert.True(index.Contains(in address)); } } } @@ -34,234 +32,218 @@ public void FindExistingMatches() [Test] public void FindNonExistingMatches() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - for (int i = 1; i <= TEST_COUNT; i++) - { - var address = new XLAddress(ws, i * 2 + 1, 3, false, false); - Assert.False(index.Contains(in address)); - } + for (var i = 1; i <= TEST_COUNT; i++) + { + var address = new XLAddress(ws, i * 2 + 1, 3, false, false); + Assert.False(index.Contains(in address)); } } [Test] public void FindExistingIntersections() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - for (int i = 1; i <= TEST_COUNT; i++) - { - var rangeAddress = new XLRangeAddress( - new XLAddress(ws, i * 2, 1 + i % 4, false, false), - new XLAddress(ws, i * 2 + 1, 8 - i % 3, false, false)); + for (var i = 1; i <= TEST_COUNT; i++) + { + var rangeAddress = new XLRangeAddress( + new XLAddress(ws, i * 2, 1 + i % 4, false, false), + new XLAddress(ws, i * 2 + 1, 8 - i % 3, false, false)); - Assert.True(index.Intersects(in rangeAddress)); - } + Assert.True(index.Intersects(in rangeAddress)); + } - for (int i = 2; i < 4; i++) - { - var columnAddress = XLRangeAddress.EntireColumn(ws, i); - Assert.True(index.Intersects(in columnAddress)); - } + for (var i = 2; i < 4; i++) + { + var columnAddress = XLRangeAddress.EntireColumn(ws, i); + Assert.True(index.Intersects(in columnAddress)); } } [Test] public void FindNonExistingIntersections() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - for (int i = 1; i <= TEST_COUNT; i++) - { - var rangeAddress = new XLRangeAddress( - new XLAddress(ws, i * 2 + 1, 1 + i % 4, false, false), - new XLAddress(ws, i * 2 + 1, 8 - i % 3, false, false)); - - Assert.False(index.Intersects(in rangeAddress)); - } + for (var i = 1; i <= TEST_COUNT; i++) + { + var rangeAddress = new XLRangeAddress( + new XLAddress(ws, i * 2 + 1, 1 + i % 4, false, false), + new XLAddress(ws, i * 2 + 1, 8 - i % 3, false, false)); - var columnAddress = XLRangeAddress.EntireColumn(ws, 1); - Assert.False(index.Intersects(in columnAddress)); - columnAddress = XLRangeAddress.EntireColumn(ws, 5); - Assert.False(index.Intersects(in columnAddress)); + Assert.False(index.Intersects(in rangeAddress)); } + + var columnAddress = XLRangeAddress.EntireColumn(ws, 1); + Assert.False(index.Intersects(in columnAddress)); + columnAddress = XLRangeAddress.EntireColumn(ws, 5); + Assert.False(index.Intersects(in columnAddress)); } [Test] public void FindMatchAfterColumnShifting() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - ws.Column(1).InsertColumnsBefore(1000); + ws.Column(1).InsertColumnsBefore(1000); - var address = new XLAddress(ws, 102, 1004, false, false); + var address = new XLAddress(ws, 102, 1004, false, false); - Assert.True(index.Contains(in address)); - } + Assert.True(index.Contains(in address)); } [Test] public void FindIntersectionsAfterColumnShifting() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - ws.Column(3).InsertColumnsBefore(2); + ws.Column(3).InsertColumnsBefore(2); - var rangeAddress = new XLRangeAddress(ws, "F102:E103"); + var rangeAddress = new XLRangeAddress(ws, "F102:E103"); - Assert.True(index.Intersects(in rangeAddress)); - } + Assert.True(index.Intersects(in rangeAddress)); } [Test] public void FindMatchAfterRowShifting() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - ws.Row(10).InsertRowsBelow(3); + ws.Row(10).InsertRowsBelow(3); - var address = new XLAddress(ws, 103, 4, false, false); + var address = new XLAddress(ws, 103, 4, false, false); - Assert.True(index.Contains(in address)); - } + Assert.True(index.Contains(in address)); } [Test] public void FindIntersectionsAfterRowShifting() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var index = FillIndexWithTestData(ws); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var index = FillIndexWithTestData(ws); - ws.Row(10).InsertRowsBelow(3); + ws.Row(10).InsertRowsBelow(3); - var rangeAddress = new XLRangeAddress(ws, "C103:E103"); + var rangeAddress = new XLRangeAddress(ws, "C103:E103"); - Assert.True(index.Intersects(in rangeAddress)); - } + Assert.True(index.Intersects(in rangeAddress)); } [Test] public void CreateQuadTree() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var quadTree = new Quadrant(); - var range = ws.Range("BT76:CA87"); - - quadTree.Add(range); - - var level0 = quadTree; - Assert.AreEqual(1, level0.MinimumColumn); - Assert.AreEqual(XLHelper.MaxColumnNumber, level0.MaximumColumn); - Assert.AreEqual(1, level0.MinimumRow); - Assert.AreEqual(XLHelper.MaxRowNumber, level0.MaximumRow); - Assert.IsNull(level0.Ranges); - Assert.AreEqual(128, level0.Children.Count()); - Assert.True(level0.Children.All(child => child.Level == 1)); - Assert.AreEqual(64, level0.Children.Count(child => - child.MinimumColumn == 1 && - child.MaximumColumn == 8192 && - child.X == 0)); - Assert.AreEqual(64, level0.Children.Count(child => - child.MinimumColumn == 8193 && - child.MaximumColumn == 16384 && - child.X == 1)); - Assert.AreEqual(2, level0.Children.Count(child => - child.MinimumRow == 1 && - child.MaximumRow == 8192 && - child.Y == 0)); - Assert.AreEqual(2, level0.Children.Count(child => - child.MinimumRow == 16385 && - child.MaximumRow == 24576 && - child.Y == 2)); - - Assert.True(level0.Children.ElementAt(0).Children.Any()); - Assert.True(level0.Children.Skip(1).All(child => child.Children == null)); - - var level8 = level0 - .Children.First() // 1 - .Children.First() // 2 - .Children.First() // 3 - .Children.First() // 4 - .Children.First() // 5 - .Children.First() // 6 - .Children.First() // 7 - .Children.Last(); // 8 - - Assert.AreEqual(65, level8.MinimumColumn); - Assert.AreEqual(65, level8.MinimumRow); - Assert.AreEqual(128, level8.MaximumColumn); - Assert.AreEqual(128, level8.MaximumRow); - - var level9 = level8.Children.First(); - Assert.NotNull(level9.Ranges); - Assert.AreEqual(range, level9.Ranges.Single()); - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var quadTree = new Quadrant(); + var range = ws.Range("BT76:CA87"); + + quadTree.Add(range); + + var level0 = quadTree; + Assert.AreEqual(1, level0.MinimumColumn); + Assert.AreEqual(XLHelper.MaxColumnNumber, level0.MaximumColumn); + Assert.AreEqual(1, level0.MinimumRow); + Assert.AreEqual(XLHelper.MaxRowNumber, level0.MaximumRow); + Assert.IsNull(level0.Ranges); + Assert.AreEqual(128, level0.Children.Count()); + Assert.True(level0.Children.All(child => child.Level == 1)); + Assert.AreEqual(64, level0.Children.Count(child => + child.MinimumColumn == 1 && + child.MaximumColumn == 8192 && + child.X == 0)); + Assert.AreEqual(64, level0.Children.Count(child => + child.MinimumColumn == 8193 && + child.MaximumColumn == 16384 && + child.X == 1)); + Assert.AreEqual(2, level0.Children.Count(child => + child.MinimumRow == 1 && + child.MaximumRow == 8192 && + child.Y == 0)); + Assert.AreEqual(2, level0.Children.Count(child => + child.MinimumRow == 16385 && + child.MaximumRow == 24576 && + child.Y == 2)); + + Assert.True(level0.Children.ElementAt(0).Children.Any()); + Assert.True(level0.Children.Skip(1).All(child => child.Children == null)); + + var level8 = level0 + .Children.First() // 1 + .Children.First() // 2 + .Children.First() // 3 + .Children.First() // 4 + .Children.First() // 5 + .Children.First() // 6 + .Children.First() // 7 + .Children.Last(); // 8 + + Assert.AreEqual(65, level8.MinimumColumn); + Assert.AreEqual(65, level8.MinimumRow); + Assert.AreEqual(128, level8.MaximumColumn); + Assert.AreEqual(128, level8.MaximumRow); + + var level9 = level8.Children.First(); + Assert.NotNull(level9.Ranges); + Assert.AreEqual(range, level9.Ranges.Single()); } [Test] public void XLRangesCountChangesCorrectly() { - using (var wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; + var range1 = ws.Range("A1:B2"); + var range2 = ws.Range("A2:B3"); + var range3 = ws.Range("A1:B2"); // same as range1 + + var ranges = new XLRanges { - var ws = wb.Worksheets.Add("Sheet1") as XLWorksheet; - var range1 = ws.Range("A1:B2"); - var range2 = ws.Range("A2:B3"); - var range3 = ws.Range("A1:B2"); // same as range1 - - var ranges = new XLRanges(); - ranges.Add(range1); - Assert.AreEqual(1, ranges.Count); - ranges.Add(range2); - Assert.AreEqual(2, ranges.Count); - ranges.Add(range3); - Assert.AreEqual(2, ranges.Count); - - Assert.AreEqual(ranges.Count, ranges.Count()); - - // Add many entries to activate QuadTree - for (int i = 1; i <= TEST_COUNT; i++) - { - ranges.Add(ws.Range(i * 2, 2, i * 2, 4)); - } + range1 + }; + Assert.AreEqual(1, ranges.Count); + ranges.Add(range2); + Assert.AreEqual(2, ranges.Count); + ranges.Add(range3); + Assert.AreEqual(2, ranges.Count); + + Assert.AreEqual(ranges.Count, ranges.Count); + + // Add many entries to activate QuadTree + for (var i = 1; i <= TEST_COUNT; i++) + { + ranges.Add(ws.Range(i * 2, 2, i * 2, 4)); + } - Assert.AreEqual(2 + TEST_COUNT, ranges.Count); + Assert.AreEqual(2 + TEST_COUNT, ranges.Count); - for (int i = 1; i <= TEST_COUNT; i++) - { - ranges.Remove(ws.Range(i * 2, 2, i * 2, 4)); - } + for (var i = 1; i <= TEST_COUNT; i++) + { + ranges.Remove(ws.Range(i * 2, 2, i * 2, 4)); + } - Assert.AreEqual(2, ranges.Count); + Assert.AreEqual(2, ranges.Count); - ranges.Remove(range3); - Assert.AreEqual(1, ranges.Count); - ranges.Remove(range2); - Assert.AreEqual(0, ranges.Count); - ranges.Remove(range1); - Assert.AreEqual(0, ranges.Count); - } + ranges.Remove(range3); + Assert.AreEqual(1, ranges.Count); + ranges.Remove(range2); + Assert.AreEqual(0, ranges.Count); + ranges.Remove(range1); + Assert.AreEqual(0, ranges.Count); } private IXLRangeIndex CreateRangeIndex(IXLWorksheet worksheet) @@ -272,7 +254,7 @@ private IXLRangeIndex CreateRangeIndex(IXLWorksheet worksheet) private IXLRangeIndex FillIndexWithTestData(IXLWorksheet worksheet) { var ranges = new List(); - for (int i = 1; i <= TEST_COUNT; i++) + for (var i = 1; i <= TEST_COUNT; i++) { ranges.Add(worksheet.Range(i * 2, 2, i * 2, 4)); } @@ -282,4 +264,4 @@ private IXLRangeIndex FillIndexWithTestData(IXLWorksheet worksheet) return index; } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/RangeShiftingTests.cs b/ClosedXML.Tests/Excel/Ranges/RangeShiftingTests.cs index 86507dbdf..8f7ebf0f7 100644 --- a/ClosedXML.Tests/Excel/Ranges/RangeShiftingTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/RangeShiftingTests.cs @@ -8,74 +8,64 @@ public class RangeShiftingTests [Test] public void CellReferenceRemainAfterColumnDeleted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var d4 = ws.Cell("D4"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var d4 = ws.Cell("D4"); - ws.Column("C").Delete(); + ws.Column("C").Delete(); - Assert.AreSame(d4, ws.Cell("C4")); - } + Assert.AreSame(d4, ws.Cell("C4")); } [Test] public void CellReferenceRemainAfterRowDeleted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var d4 = ws.Cell("D4"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var d4 = ws.Cell("D4"); - ws.Row(3).Delete(); + ws.Row(3).Delete(); - Assert.AreSame(d4, ws.Cell("D3")); - } + Assert.AreSame(d4, ws.Cell("D3")); } [Test] public void CellReferenceRemainAfterColumnInserted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var d4 = ws.Cell("D4"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var d4 = ws.Cell("D4"); - ws.Column("C").InsertColumnsBefore(1); + ws.Column("C").InsertColumnsBefore(1); - Assert.AreSame(d4, ws.Cell("E4")); - } + Assert.AreSame(d4, ws.Cell("E4")); } [Test] public void CellReferenceRemainAfterRowInserted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var d4 = ws.Cell("D4"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var d4 = ws.Cell("D4"); - ws.Row(3).InsertRowsAbove(1); + ws.Row(3).InsertRowsAbove(1); - Assert.AreSame(d4, ws.Cell("D5")); - } + Assert.AreSame(d4, ws.Cell("D5")); } [Test] public void CellReferenceRemainAfterRangeDeleted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var d4 = ws.Cell("D4"); - var f8 = ws.Cell("F8"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var d4 = ws.Cell("D4"); + var f8 = ws.Cell("F8"); - ws.Range("B2:C5").Delete(XLShiftDeletedCells.ShiftCellsLeft); - ws.Range("E5:F7").Delete(XLShiftDeletedCells.ShiftCellsUp); + ws.Range("B2:C5").Delete(XLShiftDeletedCells.ShiftCellsLeft); + ws.Range("E5:F7").Delete(XLShiftDeletedCells.ShiftCellsUp); - Assert.AreSame(d4, ws.Cell("B4")); - Assert.AreSame(f8, ws.Cell("F5")); - } + Assert.AreSame(d4, ws.Cell("B4")); + Assert.AreSame(f8, ws.Cell("F5")); } } } diff --git a/ClosedXML.Tests/Excel/Ranges/RangesConsolidationTests.cs b/ClosedXML.Tests/Excel/Ranges/RangesConsolidationTests.cs index 07a61d16b..1317474c5 100644 --- a/ClosedXML.Tests/Excel/Ranges/RangesConsolidationTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/RangesConsolidationTests.cs @@ -10,18 +10,20 @@ public class RangesConsolidationTests [Test] public void ConsolidateRangesSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); - var ranges = new XLRanges(); - ranges.Add(ws.Range("A1:E3")); - ranges.Add(ws.Range("A4:B10")); - ranges.Add(ws.Range("E2:F12")); - ranges.Add(ws.Range("C6:I8")); - ranges.Add(ws.Range("G9:G9")); - ranges.Add(ws.Range("C9:D9")); - ranges.Add(ws.Range("H9:H9")); - ranges.Add(ws.Range("I9:I13")); - ranges.Add(ws.Range("C4:D5")); + var ranges = new XLRanges + { + ws.Range("A1:E3"), + ws.Range("A4:B10"), + ws.Range("E2:F12"), + ws.Range("C6:I8"), + ws.Range("G9:G9"), + ws.Range("C9:D9"), + ws.Range("H9:H9"), + ws.Range("I9:I13"), + ws.Range("C4:D5") + }; var consRanges = ranges.Consolidate().ToList(); @@ -37,15 +39,17 @@ public void ConsolidateRangesSameWorksheet() [Test] public void ConsolidateWideRangesSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); - var ranges = new XLRanges(); - ranges.Add(ws.Row(5)); - ranges.Add(ws.Row(7)); - ranges.Add(ws.Row(6)); - ranges.Add(ws.Column("D")); - ranges.Add(ws.Column("F")); - ranges.Add(ws.Column("E")); + var ranges = new XLRanges + { + ws.Row(5), + ws.Row(7), + ws.Row(6), + ws.Column("D"), + ws.Column("F"), + ws.Column("E") + }; var consRanges = ranges.Consolidate() .OrderBy(r => r.Worksheet.Name) @@ -62,27 +66,29 @@ public void ConsolidateWideRangesSameWorksheet() [Test] public void ConsolidateRangesDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var ws2 = wb.Worksheets.Add("Sheet2"); - var ranges = new XLRanges(); - ranges.Add(ws1.Range("A1:E3")); - ranges.Add(ws1.Range("A4:B10")); - ranges.Add(ws1.Range("E2:F12")); - ranges.Add(ws1.Range("C6:I8")); - ranges.Add(ws1.Range("G9:G9")); + var ranges = new XLRanges + { + ws1.Range("A1:E3"), + ws1.Range("A4:B10"), + ws1.Range("E2:F12"), + ws1.Range("C6:I8"), + ws1.Range("G9:G9"), - ranges.Add(ws2.Row(5)); - ranges.Add(ws2.Row(7)); - ranges.Add(ws2.Row(6)); - ranges.Add(ws2.Column("D")); - ranges.Add(ws2.Column("F")); - ranges.Add(ws2.Column("E")); + ws2.Row(5), + ws2.Row(7), + ws2.Row(6), + ws2.Column("D"), + ws2.Column("F"), + ws2.Column("E"), - ranges.Add(ws1.Range("C9:D9")); - ranges.Add(ws1.Range("H9:H9")); - ranges.Add(ws1.Range("I9:I13")); - ranges.Add(ws1.Range("C4:D5")); + ws1.Range("C9:D9"), + ws1.Range("H9:H9"), + ws1.Range("I9:I13"), + ws1.Range("C4:D5") + }; var consRanges = ranges.Consolidate() .OrderBy(r => r.Worksheet.Name) @@ -106,13 +112,15 @@ public void ConsolidateRangesDifferentWorksheets() [Test] public void ConsolidateSparsedRanges() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.Worksheets.Add("Sheet1"); - var ranges = new XLRanges(); - ranges.Add(ws.Range("A1:C1")); - ranges.Add(ws.Range("E1:G1")); - ranges.Add(ws.Range("A3:C3")); - ranges.Add(ws.Range("E3:G3")); + var ranges = new XLRanges + { + ws.Range("A1:C1"), + ws.Range("E1:G1"), + ws.Range("A3:C3"), + ws.Range("E3:G3") + }; var consRanges = ranges.Consolidate().ToList(); @@ -123,4 +131,4 @@ public void ConsolidateSparsedRanges() Assert.AreEqual("E3:G3", consRanges[3].RangeAddress.ToString()); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/UsedAndUnusedCellsTests.cs b/ClosedXML.Tests/Excel/Ranges/UsedAndUnusedCellsTests.cs index 2931ce845..084d6cd08 100644 --- a/ClosedXML.Tests/Excel/Ranges/UsedAndUnusedCellsTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/UsedAndUnusedCellsTests.cs @@ -25,7 +25,7 @@ public void SetupWorkbook() [Test] public void CountUsedCellsInRow() { - int i = 0; + var i = 0; var row = workbook.Worksheets.First().FirstRow(); foreach (var cell in row.Cells()) // Cells() returns UnUsed cells by default { @@ -63,20 +63,18 @@ public void CountUsedCellsInRow() [Test(Description = "See 1443")] public void FirstRowUsedRegression() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); - ws.Range("B3:F6").SetValue(100); + ws.Range("B3:F6").SetValue(100); - Assert.AreEqual(3, ws.FirstRowUsed(XLCellsUsedOptions.AllContents).RowNumber()); - } + Assert.AreEqual(3, ws.FirstRowUsed(XLCellsUsedOptions.AllContents).RowNumber()); } [Test] public void CountAllCellsInRow() { - int i = 0; + var i = 0; var row = workbook.Worksheets.First().FirstRow(); foreach (var cell in row.Cells(false)) // All cells in range between first and last cells used { @@ -96,7 +94,7 @@ public void CountAllCellsInRow() [Test] public void CountUsedCellsInColumn() { - int i = 0; + var i = 0; var column = workbook.Worksheets.First().FirstColumn(); foreach (var cell in column.Cells()) // Cells() returns UnUsed cells by default { @@ -132,7 +130,7 @@ public void CountUsedCellsInColumn() [Test] public void CountAllCellsInColumn() { - int i = 0; + var i = 0; var column = workbook.Worksheets.First().FirstColumn(); foreach (var cell in column.Cells(false)) // All cells in range between first and last cells used { @@ -153,7 +151,7 @@ public void CountAllCellsInColumn() public void CountCellsInWorksheet() { var ws = workbook.Worksheets.First(); - int i = 0; + var i = 0; foreach (var cell in ws.Cells()) // All cells with content or formats { @@ -166,7 +164,7 @@ public void CountCellsInWorksheet() public void CountUsedCellsInWorksheet() { var ws = workbook.Worksheets.First(); - int i = 0; + var i = 0; foreach (var cell in ws.CellsUsed()) // Only used cells in worksheet { @@ -179,7 +177,7 @@ public void CountUsedCellsInWorksheet() public void CountAllCellsInWorksheet() { var ws = workbook.Worksheets.First(); - int i = 0; + var i = 0; foreach (var cell in ws.Cells(false)) // All cells in range between first and last cells used (cartesian product of range) { @@ -191,17 +189,15 @@ public void CountAllCellsInWorksheet() [Test] public void GetCellsUsedNonRectangular() { - using (XLWorkbook wb = new XLWorkbook()) - { - var sheet = wb.AddWorksheet("page1"); + using var wb = new XLWorkbook(); + var sheet = wb.AddWorksheet("page1"); - sheet.Range("C1:E1").Value = "row1"; - sheet.Range("A2:E2").Value = "row2"; + sheet.Range("C1:E1").Value = "row1"; + sheet.Range("A2:E2").Value = "row2"; - var used = sheet.RangeUsed().RangeAddress.ToString(XLReferenceStyle.A1); + var used = sheet.RangeUsed().RangeAddress.ToString(XLReferenceStyle.A1); - Assert.AreEqual("A1:E2", used); - } + Assert.AreEqual("A1:E2", used); } [TestCase(true, "A1:D2", "A1")] @@ -217,185 +213,163 @@ public void GetCellsUsedNonRectangular() public void RangeUsedIncludesMergedCells(bool includeFormatting, string expectedRange, params string[] cellsWithValues) { - using (XLWorkbook wb = new XLWorkbook()) + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + foreach (var cellAddress in cellsWithValues) { - var ws = wb.AddWorksheet("Sheet1"); - foreach (var cellAddress in cellsWithValues) - { - ws.Cell(cellAddress).Value = "Not empty"; - } - ws.Range("B2:D2").Merge(); - - var options = includeFormatting - ? XLCellsUsedOptions.All - : XLCellsUsedOptions.AllContents | XLCellsUsedOptions.MergedRanges; - var actual = ws.RangeUsed(options).RangeAddress; - - Assert.AreEqual(expectedRange, actual.ToString()); + ws.Cell(cellAddress).Value = "Not empty"; } + ws.Range("B2:D2").Merge(); + + var options = includeFormatting + ? XLCellsUsedOptions.All + : XLCellsUsedOptions.AllContents | XLCellsUsedOptions.MergedRanges; + var actual = ws.RangeUsed(options).RangeAddress; + + Assert.AreEqual(expectedRange, actual.ToString()); } [Test] public void LastCellUsedPredicateConsidersMergedRanges() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; - ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; - ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; - ws.Range("A1:C1").Merge(); - ws.Range("A2:C2").Merge(); - ws.Range("A3:C3").Merge(); - - var actual = ws.LastCellUsed(XLCellsUsedOptions.All, - c => c.Style.Fill.BackgroundColor == XLColor.Yellow); - - Assert.AreEqual("C2", actual.Address.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; + ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; + ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; + ws.Range("A1:C1").Merge(); + ws.Range("A2:C2").Merge(); + ws.Range("A3:C3").Merge(); + + var actual = ws.LastCellUsed(XLCellsUsedOptions.All, + c => c.Style.Fill.BackgroundColor == XLColor.Yellow); + + Assert.AreEqual("C2", actual.Address.ToString()); } [Test] public void FirstCellUsedPredicateConsidersMergedRanges() { - using (XLWorkbook wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; - ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; - ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; - ws.Range("A1:C1").Merge(); - ws.Range("A2:C2").Merge(); - ws.Range("A3:C3").Merge(); - - var actual = ws.FirstCellUsed(XLCellsUsedOptions.All, - c => c.Style.Fill.BackgroundColor == XLColor.Yellow); - - Assert.AreEqual("A2", actual.Address.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Style.Fill.BackgroundColor = XLColor.Red; + ws.Cell("A2").Style.Fill.BackgroundColor = XLColor.Yellow; + ws.Cell("A3").Style.Fill.BackgroundColor = XLColor.Green; + ws.Range("A1:C1").Merge(); + ws.Range("A2:C2").Merge(); + ws.Range("A3:C3").Merge(); + + var actual = ws.FirstCellUsed(XLCellsUsedOptions.All, + c => c.Style.Fill.BackgroundColor == XLColor.Yellow); + + Assert.AreEqual("A2", actual.Address.ToString()); } [Test] public void ApplyingDataValidationMakesCellNotEmpty() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Range("B2:B12").CreateDataValidation() - .Decimal.EqualOrGreaterThan(0); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Range("B2:B12").CreateDataValidation() + .Decimal.EqualOrGreaterThan(0); - var usedCells = ws.CellsUsed(XLCellsUsedOptions.All).ToList(); + var usedCells = ws.CellsUsed(XLCellsUsedOptions.All).ToList(); - Assert.AreEqual(11, usedCells.Count); - Assert.AreEqual("B2", usedCells.First().Address.ToString()); - Assert.AreEqual("B12", usedCells.Last().Address.ToString()); - } + Assert.AreEqual(11, usedCells.Count); + Assert.AreEqual("B2", usedCells.First().Address.ToString()); + Assert.AreEqual("B12", usedCells.Last().Address.ToString()); } [Test] public void MergeMakesCellNotEmpty() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Range("B2:B12").Merge(); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Range("B2:B12").Merge(); - var usedCells = ws.CellsUsed(XLCellsUsedOptions.All).ToList(); + var usedCells = ws.CellsUsed(XLCellsUsedOptions.All).ToList(); - Assert.AreEqual(11, usedCells.Count); - Assert.AreEqual("B2", usedCells.First().Address.ToString()); - Assert.AreEqual("B12", usedCells.Last().Address.ToString()); - } + Assert.AreEqual(11, usedCells.Count); + Assert.AreEqual("B2", usedCells.First().Address.ToString()); + Assert.AreEqual("B12", usedCells.Last().Address.ToString()); } [Test] public void FirstCellUsedNotHangingOnLargeCFRules() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.AddConditionalFormat().WhenIsBlank().Fill.SetBackgroundColor(XLColor.Gold); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.AddConditionalFormat().WhenIsBlank().Fill.SetBackgroundColor(XLColor.Gold); - var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); + var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual("A1", firstCell.Address.ToString()); - } + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual("A1", firstCell.Address.ToString()); } [Test] public void LastCellUsedNotHangingOnLargeCFRules() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.AddConditionalFormat().WhenIsBlank().Fill.SetBackgroundColor(XLColor.Gold); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.AddConditionalFormat().WhenIsBlank().Fill.SetBackgroundColor(XLColor.Gold); - var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); + var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); - } + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); } [Test] public void FirstCellUsedNotHangingOnLargeDVRules() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.CreateDataValidation().WholeNumber.GreaterThan(0); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.CreateDataValidation().WholeNumber.GreaterThan(0); - var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); + var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual("A1", firstCell.Address.ToString()); - } + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual("A1", firstCell.Address.ToString()); } [Test] public void LastCellUsedNotHangingOnLargeDVRules() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.CreateDataValidation().WholeNumber.GreaterThan(0); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.CreateDataValidation().WholeNumber.GreaterThan(0); - var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); + var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); - } + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); } [Test] public void FirstCellUsedNotHangingOnLargeMergedRanges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Merge(); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Merge(); - var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); + var firstCell = ws.FirstCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual("A1", firstCell.Address.ToString()); - } + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual("A1", firstCell.Address.ToString()); } [Test] public void LastCellUsedNotHangingOnLargeMergedRanges() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Merge(); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Merge(); - var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); + var lastCell = ws.LastCellUsed(XLCellsUsedOptions.All); - Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); - Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); - } + Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); + Assert.AreEqual(XLHelper.LastCell, lastCell.Address.ToString()); } } } diff --git a/ClosedXML.Tests/Excel/Ranges/XLRangeAddressTests.cs b/ClosedXML.Tests/Excel/Ranges/XLRangeAddressTests.cs index 256a8abaa..166956ee5 100644 --- a/ClosedXML.Tests/Excel/Ranges/XLRangeAddressTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/XLRangeAddressTests.cs @@ -2,7 +2,7 @@ using NUnit.Framework; using System; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Ranges { [TestFixture] public class XLRangeAddressTests @@ -10,8 +10,9 @@ public class XLRangeAddressTests [Test] public void ToStringTest() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRangeAddress address = ws.Cell(1, 1).AsRange().RangeAddress; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var address = ws.Cell(1, 1).AsRange().RangeAddress; Assert.AreEqual("A1:A1", address.ToString()); Assert.AreEqual("Sheet1!R1C1:R1C1", address.ToString(XLReferenceStyle.R1C1, true)); @@ -31,8 +32,8 @@ public void ToStringTest() [Test] public void ToStringTestWithSpace() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); - IXLRangeAddress address = ws.Cell(1, 1).AsRange().RangeAddress; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); + var address = ws.Cell(1, 1).AsRange().RangeAddress; Assert.AreEqual("A1:A1", address.ToString()); Assert.AreEqual("'Sheet 1'!R1C1:R1C1", address.ToString(XLReferenceStyle.R1C1, true)); @@ -62,7 +63,8 @@ public void ToStringTestWithSpace() [TestCase("$B$5:$E$2", "$B$2:$E$5")] public void RangeAddressNormalizeTest(string inputAddress, string expectedAddress) { - XLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1") as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.Worksheets.Add("Sheet 1") as XLWorksheet; var rangeAddress = new XLRangeAddress(ws, inputAddress); var normalizedAddress = rangeAddress.Normalize(); @@ -185,31 +187,30 @@ public void InvalidRangeAddressOnDeletedWorksheetToStringRelativeTest() [Test] public void FullSpanAddressCannotChange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var wsRange = ws.AsRange(); - var row = ws.FirstRow().RowBelow(4).AsRange(); - var column = ws.FirstColumn().ColumnRight(4).AsRange(); + var wsRange = ws.AsRange(); + var row = ws.FirstRow().RowBelow(4).AsRange(); + var column = ws.FirstColumn().ColumnRight(4).AsRange(); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", wsRange.RangeAddress.ToString()); - Assert.AreEqual("5:5", row.RangeAddress.ToString()); - Assert.AreEqual("E:E", column.RangeAddress.ToString()); + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", wsRange.RangeAddress.ToString()); + Assert.AreEqual("5:5", row.RangeAddress.ToString()); + Assert.AreEqual("E:E", column.RangeAddress.ToString()); - ws.Columns("Y:Z").Delete(); - ws.Rows("9:10").Delete(); + ws.Columns("Y:Z").Delete(); + ws.Rows("9:10").Delete(); - Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", wsRange.RangeAddress.ToString()); - Assert.AreEqual("5:5", row.RangeAddress.ToString()); - Assert.AreEqual("E:E", column.RangeAddress.ToString()); - } + Assert.AreEqual($"1:{XLHelper.MaxRowNumber}", wsRange.RangeAddress.ToString()); + Assert.AreEqual("5:5", row.RangeAddress.ToString()); + Assert.AreEqual("E:E", column.RangeAddress.ToString()); } [Test] public void RangeAddressIsNormalized() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); XLRangeAddress rangeAddress; @@ -249,7 +250,7 @@ public void AsRangeTests() Assert.IsTrue(rangeAddress.IsNormalized); Assert.Throws(() => rangeAddress.AsRange()); - var ws = new XLWorkbook().AddWorksheet() as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet() as XLWorksheet; rangeAddress = new XLRangeAddress ( new XLAddress(ws, 1, 1, false, false), @@ -264,7 +265,8 @@ public void AsRangeTests() [Test] public void RelativeRanges() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); IXLRangeAddress rangeAddress; @@ -292,7 +294,7 @@ public void RelativeRanges() [Test] public void TestSpanProperties() { - var ws = new XLWorkbook().AddWorksheet() as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet() as XLWorksheet; var range = ws.Range("B3:E5"); var rangeAddress = range.RangeAddress as IXLRangeAddress; @@ -301,7 +303,7 @@ public void TestSpanProperties() Assert.AreEqual(12, rangeAddress.NumberOfCells); range = ws.Range("E5:B3"); - rangeAddress = range.RangeAddress as IXLRangeAddress; + rangeAddress = range.RangeAddress; Assert.AreEqual(4, rangeAddress.ColumnSpan); Assert.AreEqual(3, rangeAddress.RowSpan); Assert.AreEqual(12, rangeAddress.NumberOfCells); @@ -321,7 +323,7 @@ public void TestSpanProperties() private IXLRangeAddress ProduceInvalidAddress() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); var range = ws.Range("A1:B2"); ws.Rows(1, 5).Delete(); @@ -330,7 +332,7 @@ private IXLRangeAddress ProduceInvalidAddress() private IXLRangeAddress ProduceAddressOnDeletedWorksheet() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet 1"); var address = ws.Range("A1:B2").RangeAddress; ws.Delete(); @@ -346,4 +348,4 @@ private IXLRangeAddress ProduceInvalidAddressOnDeletedWorksheet() #endregion Private Methods } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Ranges/XLRangeBaseTests.cs b/ClosedXML.Tests/Excel/Ranges/XLRangeBaseTests.cs index 38ccbc53d..9fc1b32c6 100644 --- a/ClosedXML.Tests/Excel/Ranges/XLRangeBaseTests.cs +++ b/ClosedXML.Tests/Excel/Ranges/XLRangeBaseTests.cs @@ -1,10 +1,11 @@ using ClosedXML.Excel; +using ClosedXML.Excel.Ranges; using NUnit.Framework; using System; using System.Collections.Generic; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Ranges { [TestFixture] public class XLRangeBaseTests @@ -12,81 +13,81 @@ public class XLRangeBaseTests [Test] public void IsEmpty1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(); - bool expected = true; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + _ = ws.Cell(1, 1); + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(XLCellsUsedOptions.All); - bool expected = true; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + _ = ws.Cell(1, 1); + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(XLCellsUsedOptions.All); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(); - bool expected = true; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty4() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(XLCellsUsedOptions.AllContents); - bool expected = true; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(XLCellsUsedOptions.AllContents); + var expected = true; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty5() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Style.Fill.BackgroundColor = XLColor.Red; - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(XLCellsUsedOptions.All); - bool expected = false; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(XLCellsUsedOptions.All); + var expected = false; Assert.AreEqual(expected, actual); } [Test] public void IsEmpty6() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.Value = "X"; - IXLRange range = ws.Range("A1:B2"); - bool actual = range.IsEmpty(); - bool expected = false; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = false; Assert.AreEqual(expected, actual); } [Test] public void SingleCell() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).Value = "Hello World!"; wb.NamedRanges.Add("SingleCell", "Sheet1!$A$1"); - IXLRange range = wb.Range("SingleCell"); + var range = wb.Range("SingleCell"); Assert.AreEqual(1, range.CellsUsed().Count()); Assert.AreEqual("Hello World!", range.CellsUsed().Single().GetString()); } @@ -94,17 +95,17 @@ public void SingleCell() [Test] public void TableRange() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - IXLRangeColumn rangeColumn = ws.Column(1).Column(1, 4); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var rangeColumn = ws.Column(1).Column(1, 4); rangeColumn.Cell(1).Value = "FName"; rangeColumn.Cell(2).Value = "John"; rangeColumn.Cell(3).Value = "Hank"; rangeColumn.Cell(4).Value = "Dagny"; - IXLTable table = rangeColumn.CreateTable(); - wb.NamedRanges.Add("FNameColumn", String.Format("{0}[{1}]", table.Name, "FName")); + var table = rangeColumn.CreateTable(); + wb.NamedRanges.Add("FNameColumn", string.Format("{0}[{1}]", table.Name, "FName")); - IXLRange namedRange = wb.Range("FNameColumn"); + var namedRange = wb.Range("FNameColumn"); Assert.AreEqual(3, namedRange.Cells().Count()); Assert.IsTrue( namedRange.CellsUsed().Select(cell => cell.GetString()).SequenceEqual(new[] { "John", "Hank", "Dagny" })); @@ -113,8 +114,8 @@ public void TableRange() [Test] public void WsNamedCell() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); Assert.AreEqual("Test", ws.Cell("TestCell").GetString()); } @@ -122,11 +123,11 @@ public void WsNamedCell() [Test] public void WsNamedCells() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); ws.Cell(2, 1).SetValue("B"); - IXLCells cells = ws.Cells("TestCell, A2"); + var cells = ws.Cells("TestCell, A2"); Assert.AreEqual("Test", cells.First().GetString()); Assert.AreEqual("B", cells.Last().GetString()); } @@ -134,27 +135,27 @@ public void WsNamedCells() [Test] public void WsNamedRange() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("A"); ws.Cell(2, 1).SetValue("B"); - IXLRange original = ws.Range("A1:A2"); + var original = ws.Range("A1:A2"); original.AddToNamed("TestRange", XLScope.Worksheet); - IXLRange named = ws.Range("TestRange"); + var named = ws.Range("TestRange"); Assert.AreEqual(original.RangeAddress.ToStringFixed(), named.RangeAddress.ToString()); } [Test] public void WsNamedRanges() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 1).SetValue("A"); ws.Cell(2, 1).SetValue("B"); ws.Cell(3, 1).SetValue("C"); - IXLRange original = ws.Range("A1:A2"); + var original = ws.Range("A1:A2"); original.AddToNamed("TestRange", XLScope.Worksheet); - IXLRanges namedRanges = ws.Ranges("TestRange, A3"); + var namedRanges = ws.Ranges("TestRange, A3"); Assert.AreEqual(original.RangeAddress.ToStringFixed(), namedRanges.First().RangeAddress.ToString()); Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); } @@ -162,10 +163,10 @@ public void WsNamedRanges() [Test] public void WsNamedRangesOneString() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3"); - IXLRanges namedRanges = ws.Ranges("TestRange"); + var namedRanges = ws.Ranges("TestRange"); Assert.AreEqual("$A$1:$A$1", namedRanges.First().RangeAddress.ToStringFixed()); Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); @@ -174,7 +175,7 @@ public void WsNamedRangesOneString() //[Test] //public void WsNamedRangeLiteral() //{ - // var wb = new XLWorkbook(); + //using var wb = new XLWorkbook(); // var ws = wb.Worksheets.Add("Sheet1"); // ws.NamedRanges.Add("TestRange", "\"Hello\""); // using (MemoryStream memoryStream = new MemoryStream()) @@ -190,126 +191,114 @@ public void WsNamedRangesOneString() [Test] public void GrowRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - Assert.AreEqual("A1:B2", ws.Cell("A1").AsRange().Grow().RangeAddress.ToString()); - Assert.AreEqual("A1:B3", ws.Cell("A2").AsRange().Grow().RangeAddress.ToString()); - Assert.AreEqual("A1:C2", ws.Cell("B1").AsRange().Grow().RangeAddress.ToString()); - - Assert.AreEqual("E4:G6", ws.Cell("F5").AsRange().Grow().RangeAddress.ToString()); - Assert.AreEqual("D3:H7", ws.Cell("F5").AsRange().Grow(2).RangeAddress.ToString()); - Assert.AreEqual("A1:DB105", ws.Cell("F5").AsRange().Grow(100).RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.AreEqual("A1:B2", ws.Cell("A1").AsRange().Grow().RangeAddress.ToString()); + Assert.AreEqual("A1:B3", ws.Cell("A2").AsRange().Grow().RangeAddress.ToString()); + Assert.AreEqual("A1:C2", ws.Cell("B1").AsRange().Grow().RangeAddress.ToString()); + + Assert.AreEqual("E4:G6", ws.Cell("F5").AsRange().Grow().RangeAddress.ToString()); + Assert.AreEqual("D3:H7", ws.Cell("F5").AsRange().Grow(2).RangeAddress.ToString()); + Assert.AreEqual("A1:DB105", ws.Cell("F5").AsRange().Grow(100).RangeAddress.ToString()); } [Test] public void ShrinkRange() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - Assert.Null(ws.Cell("A1").AsRange().Shrink()); - Assert.Null(ws.Range("B2:C3").Shrink()); - Assert.AreEqual("C3:C3", ws.Range("B2:D4").Shrink().RangeAddress.ToString()); - Assert.AreEqual("K11:P16", ws.Range("A1:Z26").Shrink(10).RangeAddress.ToString()); - - // Grow and shrink back - Assert.AreEqual("Z26:Z26", ws.Cell("Z26").AsRange().Grow(10).Shrink(10).RangeAddress.ToString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.Null(ws.Cell("A1").AsRange().Shrink()); + Assert.Null(ws.Range("B2:C3").Shrink()); + Assert.AreEqual("C3:C3", ws.Range("B2:D4").Shrink().RangeAddress.ToString()); + Assert.AreEqual("K11:P16", ws.Range("A1:Z26").Shrink(10).RangeAddress.ToString()); + + // Grow and shrink back + Assert.AreEqual("Z26:Z26", ws.Cell("Z26").AsRange().Grow(10).Shrink(10).RangeAddress.ToString()); } [Test] public void Intersection() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - Assert.AreEqual("D9:G11", ws.Range("B9:I11").Intersection(ws.Range("D4:G16")).ToString()); - Assert.AreEqual("E9:G11", ws.Range("E9:I11").Intersection(ws.Range("D4:G16")).ToString()); - Assert.AreEqual("E9:E9", ws.Cell("E9").AsRange().Intersection(ws.Range("D4:G16")).ToString()); - Assert.AreEqual("E9:E9", ws.Range("D4:G16").Intersection(ws.Cell("E9").AsRange()).ToString()); + Assert.AreEqual("D9:G11", ws.Range("B9:I11").Intersection(ws.Range("D4:G16")).ToString()); + Assert.AreEqual("E9:G11", ws.Range("E9:I11").Intersection(ws.Range("D4:G16")).ToString()); + Assert.AreEqual("E9:E9", ws.Cell("E9").AsRange().Intersection(ws.Range("D4:G16")).ToString()); + Assert.AreEqual("E9:E9", ws.Range("D4:G16").Intersection(ws.Cell("E9").AsRange()).ToString()); - XLRangeAddress rangeAddress; + XLRangeAddress rangeAddress; - rangeAddress = (XLRangeAddress)ws.Cell("C3").AsRange().Intersection(ws.Cell("A1").AsRange()); - Assert.IsFalse(rangeAddress.IsValid); + rangeAddress = (XLRangeAddress)ws.Cell("C3").AsRange().Intersection(ws.Cell("A1").AsRange()); + Assert.IsFalse(rangeAddress.IsValid); - rangeAddress = (XLRangeAddress)ws.Cell("A1").AsRange().Intersection(ws.Cell("C3").AsRange()); - Assert.IsFalse(rangeAddress.IsValid); + rangeAddress = (XLRangeAddress)ws.Cell("A1").AsRange().Intersection(ws.Cell("C3").AsRange()); + Assert.IsFalse(rangeAddress.IsValid); - Assert.Null(ws.Range("A1:C3").Intersection(null)); + Assert.Null(ws.Range("A1:C3").Intersection(null)); - var otherWs = wb.AddWorksheet("Sheet2"); - Assert.Null(ws.Intersection(otherWs)); - Assert.Null(ws.Cell("A1").AsRange().Intersection(otherWs.Cell("A2").AsRange())); - } + var otherWs = wb.AddWorksheet("Sheet2"); + Assert.Null(ws.Intersection(otherWs)); + Assert.Null(ws.Cell("A1").AsRange().Intersection(otherWs.Cell("A2").AsRange())); } [Test] public void Union() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - Assert.AreEqual(64, ws.Range("B9:I11").Union(ws.Range("D4:G16")).Count()); - Assert.AreEqual(58, ws.Range("E9:I11").Union(ws.Range("D4:G16")).Count()); - Assert.AreEqual(52, ws.Cell("E9").AsRange().Union(ws.Range("D4:G16")).Count()); - Assert.AreEqual(52, ws.Range("D4:G16").Union(ws.Cell("E9").AsRange()).Count()); + Assert.AreEqual(64, ws.Range("B9:I11").Union(ws.Range("D4:G16")).Count()); + Assert.AreEqual(58, ws.Range("E9:I11").Union(ws.Range("D4:G16")).Count()); + Assert.AreEqual(52, ws.Cell("E9").AsRange().Union(ws.Range("D4:G16")).Count()); + Assert.AreEqual(52, ws.Range("D4:G16").Union(ws.Cell("E9").AsRange()).Count()); - Assert.AreEqual(2, ws.Cell("A1").AsRange().Union(ws.Cell("C3").AsRange()).Count()); + Assert.AreEqual(2, ws.Cell("A1").AsRange().Union(ws.Cell("C3").AsRange()).Count()); - Assert.AreEqual(9, ws.Range("A1:C3").Union(null).Count()); + Assert.AreEqual(9, ws.Range("A1:C3").Union(null).Count()); - var otherWs = wb.AddWorksheet("Sheet2"); - Assert.False(ws.Union(otherWs).Any()); - Assert.False(ws.Cell("A1").AsRange().Union(otherWs.Cell("A2").AsRange()).Any()); - } + var otherWs = wb.AddWorksheet("Sheet2"); + Assert.False(ws.Union(otherWs).Any()); + Assert.False(ws.Cell("A1").AsRange().Union(otherWs.Cell("A2").AsRange()).Any()); } [Test] public void Difference() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - Assert.AreEqual(12, ws.Range("B9:I11").Difference(ws.Range("D4:G16")).Count()); - Assert.AreEqual(6, ws.Range("E9:I11").Difference(ws.Range("D4:G16")).Count()); - Assert.AreEqual(0, ws.Cell("E9").AsRange().Difference(ws.Range("D4:G16")).Count()); - Assert.AreEqual(51, ws.Range("D4:G16").Difference(ws.Cell("E9").AsRange()).Count()); + Assert.AreEqual(12, ws.Range("B9:I11").Difference(ws.Range("D4:G16")).Count()); + Assert.AreEqual(6, ws.Range("E9:I11").Difference(ws.Range("D4:G16")).Count()); + Assert.AreEqual(0, ws.Cell("E9").AsRange().Difference(ws.Range("D4:G16")).Count()); + Assert.AreEqual(51, ws.Range("D4:G16").Difference(ws.Cell("E9").AsRange()).Count()); - Assert.AreEqual(1, ws.Cell("A1").AsRange().Difference(ws.Cell("C3").AsRange()).Count()); + Assert.AreEqual(1, ws.Cell("A1").AsRange().Difference(ws.Cell("C3").AsRange()).Count()); - Assert.AreEqual(9, ws.Range("A1:C3").Difference(null).Count()); + Assert.AreEqual(9, ws.Range("A1:C3").Difference(null).Count()); - var otherWs = wb.AddWorksheet("Sheet2"); - Assert.False(ws.Difference(otherWs).Any()); - Assert.False(ws.Cell("A1").AsRange().Difference(otherWs.Cell("A2").AsRange()).Any()); - } + var otherWs = wb.AddWorksheet("Sheet2"); + Assert.False(ws.Difference(otherWs).Any()); + Assert.False(ws.Cell("A1").AsRange().Difference(otherWs.Cell("A2").AsRange()).Any()); } [Test] public void SurroundingCells() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - Assert.AreEqual(3, ws.FirstCell().AsRange().SurroundingCells().Count()); - Assert.AreEqual(8, ws.Cell("C3").AsRange().SurroundingCells().Count()); - Assert.AreEqual(16, ws.Range("C3:D6").AsRange().SurroundingCells().Count()); + Assert.AreEqual(3, ws.FirstCell().AsRange().SurroundingCells().Count()); + Assert.AreEqual(8, ws.Cell("C3").AsRange().SurroundingCells().Count()); + Assert.AreEqual(16, ws.Range("C3:D6").AsRange().SurroundingCells().Count()); - Assert.AreEqual(0, ws.Range("C3:D6").AsRange().SurroundingCells(c => !c.IsEmpty()).Count()); - } + Assert.AreEqual(0, ws.Range("C3:D6").AsRange().SurroundingCells(c => !c.IsEmpty()).Count()); } [Test] public void ClearConditionalFormattingsWhenRangeAbove1() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:D7").AddConditionalFormat(); ws.Range("B2:E3").Clear(XLClearOptions.ConditionalFormats); @@ -320,7 +309,7 @@ public void ClearConditionalFormattingsWhenRangeAbove1() [Test] public void ClearConditionalFormattingsWhenRangeAbove2() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:D7").AddConditionalFormat(); ws.Range("C3:D3").Clear(XLClearOptions.ConditionalFormats); @@ -331,7 +320,7 @@ public void ClearConditionalFormattingsWhenRangeAbove2() [Test] public void ClearConditionalFormattingsWhenRangeBelow1() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:D7").AddConditionalFormat(); ws.Range("B7:E8").Clear(XLClearOptions.ConditionalFormats); @@ -342,7 +331,7 @@ public void ClearConditionalFormattingsWhenRangeBelow1() [Test] public void ClearConditionalFormattingsWhenRangeBelow2() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:D7").AddConditionalFormat(); ws.Range("C7:D7").Clear(XLClearOptions.ConditionalFormats); @@ -353,7 +342,7 @@ public void ClearConditionalFormattingsWhenRangeBelow2() [Test] public void ClearConditionalFormattingsWhenRangeRowInMiddle() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:D7").AddConditionalFormat(); ws.Range("C5:E5").Clear(XLClearOptions.ConditionalFormats); @@ -365,7 +354,7 @@ public void ClearConditionalFormattingsWhenRangeRowInMiddle() [Test] public void ClearConditionalFormattingsWhenRangeColumnInMiddle() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:G4").AddConditionalFormat(); ws.Range("E2:E4").Clear(XLClearOptions.ConditionalFormats); @@ -377,7 +366,7 @@ public void ClearConditionalFormattingsWhenRangeColumnInMiddle() [Test] public void ClearConditionalFormattingsWhenRangeContainsFormatWhole() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:G4").AddConditionalFormat(); ws.Range("B2:G4").Clear(XLClearOptions.ConditionalFormats); @@ -387,7 +376,7 @@ public void ClearConditionalFormattingsWhenRangeContainsFormatWhole() [Test] public void NoClearConditionalFormattingsWhenRangePartiallySuperimposed() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("C3:G4").AddConditionalFormat(); ws.Range("C2:D3").Clear(XLClearOptions.ConditionalFormats); @@ -399,10 +388,12 @@ public void NoClearConditionalFormattingsWhenRangePartiallySuperimposed() [Test] public void RangesRemoveAllWithoutDispose() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var ranges = new XLRanges(); - ranges.Add(ws.Range("A1:A2")); - ranges.Add(ws.Range("B1:B2")); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var ranges = new XLRanges + { + ws.Range("A1:A2"), + ws.Range("B1:B2") + }; var rangesCopy = ranges.ToList(); ranges.RemoveAll(null, false); @@ -417,11 +408,13 @@ public void RangesRemoveAllWithoutDispose() [Test] public void RangesRemoveAllByCriteria() { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var ranges = new XLRanges(); - ranges.Add(ws.Range("A1:A2")); - ranges.Add(ws.Range("B1:B3")); - ranges.Add(ws.Range("C1:C4")); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var ranges = new XLRanges + { + ws.Range("A1:A2"), + ws.Range("B1:B3"), + ws.Range("C1:C4") + }; var otherRange = ws.Range("A3:D3"); ranges.RemoveAll(r => r.Intersects(otherRange)); @@ -433,19 +426,21 @@ public void RangesRemoveAllByCriteria() [Test] public void XLRangesReturnsRangesInDeterministicOrder() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var ws2 = wb.Worksheets.Add("Another sheet"); - var ranges = new XLRanges(); - ranges.Add(ws2.Range("F1:F12")); - ranges.Add(ws1.Range("F12:F16")); - ranges.Add(ws1.Range("B1:F2")); - ranges.Add(ws2.Range("A13:B14")); - ranges.Add(ws2.Range("E1:E2")); - ranges.Add(ws1.Range("E1:H2")); - ranges.Add(ws1.Range("G2:G13")); - ranges.Add(ws1.Range("G20:G20")); + var ranges = new XLRanges + { + ws2.Range("F1:F12"), + ws1.Range("F12:F16"), + ws1.Range("B1:F2"), + ws2.Range("A13:B14"), + ws2.Range("E1:E2"), + ws1.Range("E1:H2"), + ws1.Range("G2:G13"), + ws1.Range("G20:G20") + }; var expectedRanges = new List { @@ -463,7 +458,7 @@ public void XLRangesReturnsRangesInDeterministicOrder() var actualRanges = ranges.ToList(); Assert.AreEqual(expectedRanges.Count, actualRanges.Count); - for (int i = 0; i < actualRanges.Count; i++) + for (var i = 0; i < actualRanges.Count; i++) { Assert.AreEqual(expectedRanges[i], actualRanges[i]); } @@ -472,7 +467,7 @@ public void XLRangesReturnsRangesInDeterministicOrder() [Test] public void ClearRangeRemovesSparklines() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.SparklineGroups.Add("B1:B3", "C1:E3"); ws.Range("B1:C1").Clear(XLClearOptions.All); @@ -502,7 +497,7 @@ public void ClearRangeRemovesSparklines() [TestCase("B2:G7", "H1:H8", true, "B2:G7")] public void CanSplitRange(string rangeAddress, string splitBy, bool includeIntersection, string expectedResult) { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var range = ws.Range(rangeAddress) as XLRange; var splitter = ws.Range(splitBy); @@ -514,4 +509,4 @@ public void CanSplitRange(string rangeAddress, string splitBy, bool includeInter Assert.AreEqual(expectedResult, actualAddresses); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/RichText/XLRichStringTests.cs b/ClosedXML.Tests/Excel/RichText/XLRichStringTests.cs index e58725624..1d063310f 100644 --- a/ClosedXML.Tests/Excel/RichText/XLRichStringTests.cs +++ b/ClosedXML.Tests/Excel/RichText/XLRichStringTests.cs @@ -4,7 +4,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.RichText { /// /// This is a test class for XLRichStringTests and is intended @@ -16,14 +16,14 @@ public class XLRichStringTests [Test] public void AccessRichTextTest1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.CreateRichText().AddText("12"); cell.DataType = XLDataType.Number; Assert.AreEqual(12.0, cell.GetDouble()); - IXLRichText richText = cell.GetRichText(); + var richText = cell.GetRichText(); Assert.AreEqual("12", richText.ToString()); @@ -42,11 +42,11 @@ public void AccessRichTextTest1() [Test] public void AddTextTest1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - IXLRichText richString = cell.CreateRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var richString = cell.CreateRichText(); - string text = "Hello"; + var text = "Hello"; richString.AddText(text).SetBold().SetFontColor(XLColor.Red); Assert.AreEqual(cell.GetString(), text); @@ -62,15 +62,15 @@ public void AddTextTest1() [Test] public void AddTextTest2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - Int32 number = 123; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var number = 123; cell.SetValue(number).Style .Font.SetBold() .Font.SetFontColor(XLColor.Red); - string text = number.ToString(); + var text = number.ToString(); Assert.AreEqual(cell.GetRichText().ToString(), text); Assert.AreEqual(cell.GetRichText().First().Bold, true); @@ -85,15 +85,15 @@ public void AddTextTest2() [Test] public void AddTextTest3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); - Int32 number = 123; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var number = 123; cell.Value = number; cell.Style .Font.SetBold() .Font.SetFontColor(XLColor.Red); - string text = number.ToString(); + var text = number.ToString(); Assert.AreEqual(cell.GetRichText().ToString(), text); Assert.AreEqual(cell.GetRichText().First().Bold, true); @@ -111,16 +111,16 @@ public void AddTextTest3() [Test] public void ClearTest() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); richString.AddText(" "); richString.AddText("World!"); richString.ClearText(); - String expected = String.Empty; - String actual = richString.ToString(); + var expected = string.Empty; + var actual = richString.ToString(); Assert.AreEqual(expected, actual); Assert.AreEqual(0, richString.Count); @@ -129,8 +129,8 @@ public void ClearTest() [Test] public void CountTest() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); richString.AddText(" "); @@ -142,8 +142,8 @@ public void CountTest() [Test] public void HasRichTextTest1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLCell cell = ws.Cell(1, 1); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); cell.GetRichText().AddText("123"); Assert.AreEqual(true, cell.HasRichText); @@ -179,12 +179,12 @@ public void HasRichTextTest1() [Test] public void Substring_All_From_OneString() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); - IXLFormattedText actual = richString.Substring(0); + var actual = richString.Substring(0); Assert.AreEqual(richString.First(), actual.First()); @@ -198,14 +198,14 @@ public void Substring_All_From_OneString() [Test] public void Substring_All_From_ThreeStrings() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(0); + var actual = richString.Substring(0); Assert.AreEqual(richString.ElementAt(0), actual.ElementAt(0)); Assert.AreEqual(richString.ElementAt(1), actual.ElementAt(1)); @@ -224,12 +224,12 @@ public void Substring_All_From_ThreeStrings() [Test] public void Substring_From_OneString_End() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); - IXLFormattedText actual = richString.Substring(2); + var actual = richString.Substring(2); Assert.AreEqual(1, actual.Count); // substring was in one piece @@ -263,12 +263,12 @@ public void Substring_From_OneString_End() [Test] public void Substring_From_OneString_Middle() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); - IXLFormattedText actual = richString.Substring(2, 2); + var actual = richString.Substring(2, 2); Assert.AreEqual(1, actual.Count); // substring was in one piece @@ -306,12 +306,12 @@ public void Substring_From_OneString_Middle() [Test] public void Substring_From_OneString_Start() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); - IXLFormattedText actual = richString.Substring(0, 2); + var actual = richString.Substring(0, 2); Assert.AreEqual(1, actual.Count); // substring was in one piece @@ -345,14 +345,14 @@ public void Substring_From_OneString_Start() [Test] public void Substring_From_ThreeStrings_End1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(21); + var actual = richString.Substring(21); Assert.AreEqual(1, actual.Count); // substring was in one piece @@ -394,14 +394,14 @@ public void Substring_From_ThreeStrings_End1() [Test] public void Substring_From_ThreeStrings_End2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(13); + var actual = richString.Substring(13); Assert.AreEqual(2, actual.Count); @@ -446,14 +446,14 @@ public void Substring_From_ThreeStrings_End2() [Test] public void Substring_From_ThreeStrings_Mid1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(5, 10); + var actual = richString.Substring(5, 10); Assert.AreEqual(2, actual.Count); @@ -472,14 +472,14 @@ public void Substring_From_ThreeStrings_Mid1() [Test] public void Substring_From_ThreeStrings_Mid2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(5, 15); + var actual = richString.Substring(5, 15); Assert.AreEqual(3, actual.Count); @@ -499,14 +499,14 @@ public void Substring_From_ThreeStrings_Mid2() [Test] public void Substring_From_ThreeStrings_Start1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(0, 4); + var actual = richString.Substring(0, 4); Assert.AreEqual(1, actual.Count); // substring was in one piece @@ -548,14 +548,14 @@ public void Substring_From_ThreeStrings_Start1() [Test] public void Substring_From_ThreeStrings_Start2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Good Morning"); richString.AddText(" my "); richString.AddText("neighbors!"); - IXLFormattedText actual = richString.Substring(0, 15); + var actual = richString.Substring(0, 15); Assert.AreEqual(2, actual.Count); @@ -600,8 +600,8 @@ public void Substring_From_ThreeStrings_Start2() [Test] public void Substring_IndexOutsideRange1() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); @@ -611,8 +611,8 @@ public void Substring_IndexOutsideRange1() [Test] public void Substring_IndexOutsideRange2() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); richString.AddText("World"); @@ -623,8 +623,8 @@ public void Substring_IndexOutsideRange2() [Test] public void Substring_IndexOutsideRange3() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); @@ -634,8 +634,8 @@ public void Substring_IndexOutsideRange3() [Test] public void Substring_IndexOutsideRange4() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); richString.AddText("World"); @@ -649,14 +649,14 @@ public void Substring_IndexOutsideRange4() [Test] public void ToStringTest() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText richString = ws.Cell(1, 1).GetRichText(); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).GetRichText(); richString.AddText("Hello"); richString.AddText(" "); richString.AddText("World"); - string expected = "Hello World"; - string actual = richString.ToString(); + var expected = "Hello World"; + var actual = richString.ToString(); Assert.AreEqual(expected, actual); richString.AddText("!"); @@ -665,7 +665,7 @@ public void ToStringTest() Assert.AreEqual(expected, actual); richString.ClearText(); - expected = String.Empty; + expected = string.Empty; actual = richString.ToString(); Assert.AreEqual(expected, actual); } @@ -673,26 +673,22 @@ public void ToStringTest() [Test(Description = "See #1361")] public void CanClearInlinedRichText() { - using (var outputStream = new MemoryStream()) + using var outputStream = new MemoryStream(); + using (var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlinedRichText\ChangeRichText\inputfile.xlsx"))) + using (var workbook = new XLWorkbook(inputStream)) { - using (var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlinedRichText\ChangeRichText\inputfile.xlsx"))) - using (var workbook = new XLWorkbook(inputStream)) - { - workbook.Worksheets.First().Cell("A1").Value = ""; - workbook.SaveAs(outputStream); - } - - using (var wb = new XLWorkbook(outputStream)) - { - Assert.AreEqual("", wb.Worksheets.First().Cell("A1").Value); - } + workbook.Worksheets.First().Cell("A1").Value = ""; + workbook.SaveAs(outputStream); } + + using var wb = new XLWorkbook(outputStream); + Assert.AreEqual("", wb.Worksheets.First().Cell("A1").Value); } [Test] public void CanChangeInlinedRichText() { - void testRichText(IXLRichText richText) + static void testRichText(IXLRichText richText) { Assert.IsNotNull(richText); Assert.IsTrue(richText.Any()); @@ -700,63 +696,62 @@ void testRichText(IXLRichText richText) Assert.AreEqual(XLColor.Red, richText.ElementAt(2).FontColor); } - using (var outputStream = new MemoryStream()) + using var outputStream = new MemoryStream(); + using (var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlinedRichText\ChangeRichText\inputfile.xlsx"))) + using (var workbook = new XLWorkbook(inputStream)) { - using (var inputStream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlinedRichText\ChangeRichText\inputfile.xlsx"))) - using (var workbook = new XLWorkbook(inputStream)) - { - var richText = workbook.Worksheets.First().Cell("A1").GetRichText(); - testRichText(richText); - richText.AddText(" - changed"); - workbook.SaveAs(outputStream); - } - - using (var wb = new XLWorkbook(outputStream)) - { - var cell = wb.Worksheets.First().Cell("A1"); - Assert.IsFalse(cell.ShareString); - Assert.IsTrue(cell.HasRichText); - var rt = cell.GetRichText(); - Assert.AreEqual("Year (range: 3 yrs) - changed", rt.ToString()); - testRichText(rt); - } + var richText = workbook.Worksheets.First().Cell("A1").GetRichText(); + testRichText(richText); + richText.AddText(" - changed"); + workbook.SaveAs(outputStream); } + + using var wb = new XLWorkbook(outputStream); + var cell = wb.Worksheets.First().Cell("A1"); + Assert.IsFalse(cell.ShareString); + Assert.IsTrue(cell.HasRichText); + var rt = cell.GetRichText(); + Assert.AreEqual("Year (range: 3 yrs) - changed", rt.ToString()); + testRichText(rt); } [Test] public void ClearInlineRichTextWhenRelevant() { - using (var ms = new MemoryStream()) + var expectedFilePath = @"Other\InlinedRichText\ChangeRichTextToFormula\output.xlsx"; + + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell = ws.FirstCell(); + var ws = wb.AddWorksheet(); + var cell = ws.FirstCell(); - cell.GetRichText().AddText("Bold").SetBold().AddText(" and red").SetBold().SetFontColor(XLColor.Red); - cell.ShareString = false; + cell.GetRichText().AddText("Bold").SetBold().AddText(" and red").SetBold().SetFontColor(XLColor.Red); + cell.ShareString = false; - //wb.SaveAs(ms); - wb.SaveAs(ms); - } - ms.Seek(0, SeekOrigin.Begin); + //wb.SaveAs(ms); + wb.SaveAs(ms); + } + ms.Seek(0, SeekOrigin.Begin); - var wb2 = new XLWorkbook(ms); - { - var ws = wb2.Worksheets.First(); - var cell = ws.FirstCell(); + var wb2 = new XLWorkbook(ms); + { + var ws = wb2.Worksheets.First(); + var cell = ws.FirstCell(); + + cell.FormulaA1 = "=1 + 2"; + wb2.SaveAs(ms); + } - cell.FormulaA1 = "=1 + 2"; - wb2.SaveAs(ms); - } + ms.Seek(0, SeekOrigin.Begin); - ms.Seek(0, SeekOrigin.Begin); + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //File.WriteAllBytes(expectedFileInVsSolution, ms.ToArray()); - return wb2; - }, @"Other\InlinedRichText\ChangeRichTextToFormula\output.xlsx"); - } + return wb2; + }, expectedFilePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Rows/RowTests.cs b/ClosedXML.Tests/Excel/Rows/RowTests.cs index 6fa203cba..7c39cbc58 100644 --- a/ClosedXML.Tests/Excel/Rows/RowTests.cs +++ b/ClosedXML.Tests/Excel/Rows/RowTests.cs @@ -1,9 +1,8 @@ using ClosedXML.Excel; using NUnit.Framework; -using System; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Rows { [TestFixture] public class RowTests @@ -21,8 +20,8 @@ public void RowsUsedIsFast() [Test] public void CopyRow() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.FirstCell().SetValue("Test").Style.Font.SetBold(); ws.FirstRow().CopyTo(ws.Row(2)); @@ -32,18 +31,18 @@ public void CopyRow() [Test] public void InsertingRowsAbove1() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLRow row1 = ws.Row(1); - IXLRow row2 = ws.Row(2); - IXLRow row3 = ws.Row(3); + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); - IXLRow rowIns = ws.Row(1).InsertRowsAbove(1).First(); + var rowIns = ws.Row(1).InsertRowsAbove(1).First(); Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); @@ -85,18 +84,18 @@ public void InsertingRowsAbove1() [Test] public void InsertingRowsAbove2() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLRow row1 = ws.Row(1); - IXLRow row2 = ws.Row(2); - IXLRow row3 = ws.Row(3); + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); - IXLRow rowIns = ws.Row(2).InsertRowsAbove(1).First(); + var rowIns = ws.Row(2).InsertRowsAbove(1).First(); Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); @@ -138,18 +137,18 @@ public void InsertingRowsAbove2() [Test] public void InsertingRowsAbove3() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - IXLRow row1 = ws.Row(1); - IXLRow row2 = ws.Row(2); - IXLRow row3 = ws.Row(3); + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); - IXLRow rowIns = ws.Row(3).InsertRowsAbove(1).First(); + var rowIns = ws.Row(3).InsertRowsAbove(1).First(); Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); @@ -191,45 +190,47 @@ public void InsertingRowsAbove3() [Test] public void InsertingRowsAbove4() { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); - ws.Row(2).Height = 15; - ws.Row(3).Height = 20; - ws.Row(4).Height = 25; - ws.Row(5).Height = 35; + ws.Row(2).Height = 15; + ws.Row(3).Height = 20; + ws.Row(4).Height = 25; + ws.Row(5).Height = 35; - ws.Row(2).FirstCell().SetValue("Row height: 15"); - ws.Row(3).FirstCell().SetValue("Row height: 20"); - ws.Row(4).FirstCell().SetValue("Row height: 25"); - ws.Row(5).FirstCell().SetValue("Row height: 35"); + ws.Row(2).FirstCell().SetValue("Row height: 15"); + ws.Row(3).FirstCell().SetValue("Row height: 20"); + ws.Row(4).FirstCell().SetValue("Row height: 25"); + ws.Row(5).FirstCell().SetValue("Row height: 35"); - ws.Range("3:3").InsertRowsAbove(1); + ws.Range("3:3").InsertRowsAbove(1); - Assert.AreEqual(15, ws.Row(2).Height); - Assert.AreEqual(20, ws.Row(4).Height); - Assert.AreEqual(25, ws.Row(5).Height); - Assert.AreEqual(35, ws.Row(6).Height); + Assert.AreEqual(15, ws.Row(2).Height); + Assert.AreEqual(20, ws.Row(4).Height); + Assert.AreEqual(25, ws.Row(5).Height); + Assert.AreEqual(35, ws.Row(6).Height); - Assert.AreEqual(20, ws.Row(3).Height); - ws.Row(3).ClearHeight(); - Assert.AreEqual(ws.RowHeight, ws.Row(3).Height); - } + Assert.AreEqual(20, ws.Row(3).Height); + ws.Row(3).ClearHeight(); + Assert.AreEqual(ws.RowHeight, ws.Row(3).Height); } [Test] public void NoRowsUsed() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - Int32 count = 0; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var count = 0; - foreach (IXLRow row in ws.RowsUsed()) + foreach (var row in ws.RowsUsed()) + { count++; + } - foreach (IXLRangeRow row in ws.Range("A1:C3").RowsUsed()) + foreach (var row in ws.Range("A1:C3").RowsUsed()) + { count++; + } Assert.AreEqual(0, count); } @@ -237,15 +238,15 @@ public void NoRowsUsed() [Test] public void RowUsed() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); ws.Cell(1, 2).SetValue("Test"); ws.Cell(1, 3).SetValue("Test"); - IXLRangeRow fromRow = ws.Row(1).RowUsed(); + var fromRow = ws.Row(1).RowUsed(); Assert.AreEqual("B1:C1", fromRow.RangeAddress.ToStringRelative()); - IXLRangeRow fromRange = ws.Range("A1:E1").FirstRow().RowUsed(); + var fromRange = ws.Range("A1:E1").FirstRow().RowUsed(); Assert.AreEqual("B1:C1", fromRange.RangeAddress.ToStringRelative()); } @@ -280,7 +281,7 @@ public void RowsUsedWithConditionalFormatting() [Test] public void UngroupFromAll() { - IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); ws.Rows(1, 2).Group(); ws.Rows(1, 2).Ungroup(true); } @@ -288,7 +289,7 @@ public void UngroupFromAll() [Test] public void NegativeRowNumberIsInvalid() { - var ws = new XLWorkbook().AddWorksheet("Sheet1") as XLWorksheet; + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1") as XLWorksheet; var row = new XLRow(ws, -1); @@ -298,10 +299,11 @@ public void NegativeRowNumberIsInvalid() [Test] public void DeleteRowOnWorksheetWithComment() { - var ws = new XLWorkbook().AddWorksheet(); + using var xLWorkbook = new XLWorkbook(); + var ws = xLWorkbook.AddWorksheet(); ws.Cell(4, 1).GetComment().AddText("test"); ws.Column(1).Width = 100; Assert.DoesNotThrow(() => ws.Row(1).Delete()); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Saving/SavingTests.cs b/ClosedXML.Tests/Excel/Saving/SavingTests.cs index 6e45f49cf..16dc8c68d 100644 --- a/ClosedXML.Tests/Excel/Saving/SavingTests.cs +++ b/ClosedXML.Tests/Excel/Saving/SavingTests.cs @@ -4,12 +4,13 @@ using DocumentFormat.OpenXml; using DocumentFormat.OpenXml.Packaging; using NUnit.Framework; +using SkiaSharp; using System; -using System.Drawing; using System.Globalization; using System.IO; using System.Linq; using System.Reflection; +using System.Runtime.InteropServices; using System.Threading; namespace ClosedXML.Tests.Excel.Saving @@ -20,67 +21,65 @@ public class SavingTests [Test] public void BooleanValueSavesAsLowerCase() { + var expectedFilePath = @"Other\Formulas\BooleanFormulaValues.xlsx"; + + using var wb = new XLWorkbook(); + // When a cell evaluates to a boolean value, the text in the XML has to be true/false (lowercase only) or 0/1 TestHelper.CreateAndCompare(() => { - var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); ws.FirstCell().FormulaA1 = "=TRUE"; + return wb; - }, @"Other\Formulas\BooleanFormulaValues.xlsx", evaluateFormulae: true); + }, expectedFilePath, evaluateFormulae: true); } [Test] public void CanSaveEmptyFile() { - using (var ms = new MemoryStream()) - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet("Sheet1"); - wb.SaveAs(ms); - } + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); + wb.SaveAs(ms); } [Test] public void CanSuccessfullySaveFileMultipleTimes() { - using (var memoryStream = new MemoryStream()) - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); + using var memoryStream = new MemoryStream(); + using var wb = new XLWorkbook(); + var sheet = wb.Worksheets.Add("TestSheet"); - // Comments might cause duplicate VmlDrawing Id's - ensure it's tested: - sheet.Cell(1, 1).GetComment().AddText("abc"); + // Comments might cause duplicate VmlDrawing Id's - ensure it's tested: + sheet.Cell(1, 1).GetComment().AddText("abc"); - wb.SaveAs(memoryStream, validate: true); + wb.SaveAs(memoryStream, validate: true); - for (int i = 1; i <= 3; i++) - { - sheet.Cell(i, 1).Value = "test" + i; - wb.SaveAs(memoryStream, validate: true); - } + for (var i = 1; i <= 3; i++) + { + sheet.Cell(i, 1).Value = "test" + i; + wb.SaveAs(memoryStream, validate: true); } } [Test] public void CanEscape_xHHHH_Correctly() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().Value = "Reserve_TT_A_BLOCAGE_CAG_x6904_2"; - wb.SaveAs(ms); - } + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().Value = "Reserve_TT_A_BLOCAGE_CAG_x6904_2"; + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - Assert.AreEqual("Reserve_TT_A_BLOCAGE_CAG_x6904_2", ws.FirstCell().Value); - } + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + Assert.AreEqual("Reserve_TT_A_BLOCAGE_CAG_x6904_2", ws.FirstCell().Value); } } @@ -89,187 +88,166 @@ public void CanSaveFileMultipleTimesAfterDeletingWorksheet() { // https://github.com/ClosedXML/ClosedXML/issues/435 - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var book1 = new XLWorkbook()) { - using (XLWorkbook book1 = new XLWorkbook()) - { - book1.AddWorksheet("sheet1"); - book1.AddWorksheet("sheet2"); - - book1.SaveAs(ms); - } - ms.Position = 0; + book1.AddWorksheet("sheet1"); + book1.AddWorksheet("sheet2"); - using (XLWorkbook book2 = new XLWorkbook(ms)) - { - var ws = book2.Worksheet(1); - Assert.AreEqual("sheet1", ws.Name); - ws.Delete(); - book2.Save(); - book2.Save(); - } + book1.SaveAs(ms); } + ms.Position = 0; + + using var book2 = new XLWorkbook(ms); + var ws = book2.Worksheet(1); + Assert.AreEqual("sheet1", ws.Name); + ws.Delete(); + book2.Save(); + book2.Save(); } [Test] public void CanSaveAndValidateFileInAnotherCulture() { - string[] cultures = new string[] { "it", "de-AT" }; + var cultures = new[] { "it", "de-AT" }; foreach (var culture in cultures) { Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture); - using (var wb = new XLWorkbook()) - { - var memoryStream = new MemoryStream(); - var ws = wb.Worksheets.Add("Sheet1"); + using var wb = new XLWorkbook(); + using var memoryStream = new MemoryStream(); + _ = wb.Worksheets.Add("Sheet1"); - wb.SaveAs(memoryStream, true); - } + Assert.DoesNotThrow(() => wb.SaveAs(memoryStream, true)); } } [Test] public void NotSaveCachedValueWhenFlagIsFalse() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var book1 = new XLWorkbook()) { - using (XLWorkbook book1 = new XLWorkbook()) - { - var sheet = book1.AddWorksheet("sheet1"); - sheet.Cell("A1").Value = 123; - sheet.Cell("A2").FormulaA1 = "A1*10"; - book1.RecalculateAllFormulas(); - var options = new SaveOptions { EvaluateFormulasBeforeSaving = false }; + var sheet = book1.AddWorksheet("sheet1"); + sheet.Cell("A1").Value = 123; + sheet.Cell("A2").FormulaA1 = "A1*10"; + book1.RecalculateAllFormulas(); + var options = new SaveOptions { EvaluateFormulasBeforeSaving = false }; - book1.SaveAs(ms, options); - } - ms.Position = 0; + book1.SaveAs(ms, options); + } + ms.Position = 0; - using (XLWorkbook book2 = new XLWorkbook(ms)) - { - var ws = book2.Worksheet(1); + using var book2 = new XLWorkbook(ms); + var ws = book2.Worksheet(1); - Assert.IsNull(ws.Cell("A2").CachedValue); - } - } + Assert.IsNull(ws.Cell("A2").CachedValue); } [Test] public void SaveCachedValueWhenFlagIsTrue() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var book1 = new XLWorkbook()) { - using (XLWorkbook book1 = new XLWorkbook()) - { - var sheet = book1.AddWorksheet("sheet1"); - sheet.Cell("A1").Value = 123; - sheet.Cell("A2").FormulaA1 = "A1*10"; - sheet.Cell("A3").FormulaA1 = "TEXT(A2, \"# ###\")"; - var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; + var sheet = book1.AddWorksheet("sheet1"); + sheet.Cell("A1").Value = 123; + sheet.Cell("A2").FormulaA1 = "A1*10"; + sheet.Cell("A3").FormulaA1 = "TEXT(A2, \"# ###\")"; + var options = new SaveOptions { EvaluateFormulasBeforeSaving = true }; - book1.SaveAs(ms, options); - } - ms.Position = 0; + book1.SaveAs(ms, options); + } + ms.Position = 0; - using (XLWorkbook book2 = new XLWorkbook(ms)) - { - var ws = book2.Worksheet(1); + using var book2 = new XLWorkbook(ms); + var ws = book2.Worksheet(1); - Assert.AreEqual(1230, ws.Cell("A2").CachedValue); + Assert.AreEqual(1230, ws.Cell("A2").CachedValue); - Assert.AreEqual("1 230", ws.Cell("A3").CachedValue); - } - } + Assert.AreEqual("1 230", ws.Cell("A3").CachedValue); } [Test] public void CanSaveAsCopyReadOnlyFile() { - using (var original = new TemporaryFile()) + using var original = new TemporaryFile(); + try { - try + using var copy = new TemporaryFile(); + // Arrange + using (var wb = new XLWorkbook()) { - using (var copy = new TemporaryFile()) - { - // Arrange - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - wb.SaveAs(original.Path); - } - File.SetAttributes(original.Path, FileAttributes.ReadOnly); - - // Act - using (var wb = new XLWorkbook(original.Path)) - { - wb.SaveAs(copy.Path); - } - - // Assert - Assert.IsTrue(File.Exists(copy.Path)); - Assert.IsFalse(File.GetAttributes(copy.Path).HasFlag(FileAttributes.ReadOnly)); - } + var sheet = wb.Worksheets.Add("TestSheet"); + wb.SaveAs(original.Path); } - finally + File.SetAttributes(original.Path, FileAttributes.ReadOnly); + + // Act + using (var wb = new XLWorkbook(original.Path)) { - // Tear down - File.SetAttributes(original.Path, FileAttributes.Normal); + wb.SaveAs(copy.Path); } + + // Assert + Assert.IsTrue(File.Exists(copy.Path)); + Assert.IsFalse(File.GetAttributes(copy.Path).HasFlag(FileAttributes.ReadOnly)); + } + finally + { + // Tear down + File.SetAttributes(original.Path, FileAttributes.Normal); } } [Test] public void CanSaveAsOverwriteExistingFile() { - using (var existing = new TemporaryFile()) + using var existing = new TemporaryFile(); + // Arrange + File.WriteAllText(existing.Path, ""); + + // Act + using (var wb = new XLWorkbook()) + { + var sheet = wb.Worksheets.Add("TestSheet"); + wb.SaveAs(existing.Path); + } + + // Assert + Assert.IsTrue(File.Exists(existing.Path)); + Assert.Greater(new FileInfo(existing.Path).Length, 0); + } + + [Test] + public void CannotSaveAsOverwriteExistingReadOnlyFile() + { + using var existing = new TemporaryFile(); + try { // Arrange File.WriteAllText(existing.Path, ""); + File.SetAttributes(existing.Path, FileAttributes.ReadOnly); // Act - using (var wb = new XLWorkbook()) + void saveAs() { + using var wb = new XLWorkbook(); var sheet = wb.Worksheets.Add("TestSheet"); wb.SaveAs(existing.Path); } // Assert - Assert.IsTrue(File.Exists(existing.Path)); - Assert.Greater(new FileInfo(existing.Path).Length, 0); - } - } - - [Test] - public void CannotSaveAsOverwriteExistingReadOnlyFile() - { - using (var existing = new TemporaryFile()) - { - try + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - // Arrange - File.WriteAllText(existing.Path, ""); - File.SetAttributes(existing.Path, FileAttributes.ReadOnly); - - // Act - TestDelegate saveAs = () => - { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("TestSheet"); - wb.SaveAs(existing.Path); - } - }; - - // Assert Assert.Throws(typeof(UnauthorizedAccessException), saveAs); } - finally - { - // Tear down - File.SetAttributes(existing.Path, FileAttributes.Normal); - } + } + finally + { + // Tear down + File.SetAttributes(existing.Path, FileAttributes.Normal); } } @@ -278,62 +256,56 @@ public void PageBreaksDontDuplicateAtSaving() { // https://github.com/ClosedXML/ClosedXML/issues/666 - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb1 = new XLWorkbook()) { - using (var wb1 = new XLWorkbook()) - { - var ws = wb1.Worksheets.Add("Page Breaks"); - ws.PageSetup.PrintAreas.Add("A1:D5"); - ws.PageSetup.AddHorizontalPageBreak(2); - ws.PageSetup.AddVerticalPageBreak(2); - wb1.SaveAs(ms); - wb1.Save(); - } - using (var wb2 = new XLWorkbook(ms)) - { - var ws = wb2.Worksheets.First(); + var ws = wb1.Worksheets.Add("Page Breaks"); + ws.PageSetup.PrintAreas.Add("A1:D5"); + ws.PageSetup.AddHorizontalPageBreak(2); + ws.PageSetup.AddVerticalPageBreak(2); + wb1.SaveAs(ms); + wb1.Save(); + } + using (var wb2 = new XLWorkbook(ms)) + { + var ws = wb2.Worksheets.First(); - Assert.AreEqual(1, ws.PageSetup.ColumnBreaks.Count); - Assert.AreEqual(1, ws.PageSetup.RowBreaks.Count); - } + Assert.AreEqual(1, ws.PageSetup.ColumnBreaks.Count); + Assert.AreEqual(1, ws.PageSetup.RowBreaks.Count); } } [Test] public void CanSaveFileWithPictureAndComment() { - using (var ms = new MemoryStream()) - using (var wb = new XLWorkbook()) - using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("D4").Value = "Hello world."; + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + using var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)).GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg"); + using var bitmap = SKCodec.Create(resourceStream); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("D4").Value = "Hello world."; - ws.AddPicture(bitmap, "MyPicture") - .WithPlacement(XLPicturePlacement.FreeFloating) - .MoveTo(50, 50) - .WithSize(200, 200); + ws.AddPicture(bitmap, "MyPicture") + .WithPlacement(XLPicturePlacement.FreeFloating) + .MoveTo(50, 50) + .WithSize(200, 200); - ws.Cell("D4").GetComment().SetVisible().AddText("This is a comment"); + ws.Cell("D4").GetComment().SetVisible().AddText("This is a comment"); - wb.SaveAs(ms); - } + wb.SaveAs(ms); } [Test] public void PreserveChartsWhenSaving() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Charts\PreserveCharts\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Charts\PreserveCharts\inputfile.xlsx")); + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - wb.SaveAs(ms); - return wb; - }, @"Other\Charts\PreserveCharts\outputfile.xlsx"); - } + var wb = new XLWorkbook(stream); + wb.SaveAs(ms); + return wb; + }, @"Other\Charts\PreserveCharts\outputfile.xlsx"); } [Test] @@ -347,7 +319,9 @@ public void DeletingAllPicturesRemovesDrawingPart() { var pictureNames = ws.Pictures.Select(pic => pic.Name).ToArray(); foreach (var name in pictureNames) + { ws.Pictures.Delete(name); + } } return wb; @@ -361,129 +335,113 @@ public void DeletingAllPicturesRemovesDrawingPart() [TestCase("xltm", SpreadsheetDocumentType.MacroEnabledTemplate)] public void SavesAsProperSpreadsheetDocumentType(string extension, SpreadsheetDocumentType expectedType) { - using (var tf = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), extension))) + using var tf = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), extension)); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add("Sheet1"); - wb.SaveAs(tf.Path); - } - - using (var package = SpreadsheetDocument.Open(tf.Path, false)) - { - Assert.AreEqual(expectedType, package.DocumentType); - } + wb.Worksheets.Add("Sheet1"); + wb.SaveAs(tf.Path); } + + using var package = SpreadsheetDocument.Open(tf.Path, false); + Assert.AreEqual(expectedType, package.DocumentType); } [Test] public void CanSaveTemplateAsWorkbook() { // See #1375 - using (var template = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "xltx"))) - using (var workbook = new TemporaryFile()) + using var template = new TemporaryFile(Path.ChangeExtension(Path.GetTempFileName(), "xltx")); + using var workbook = new TemporaryFile(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet(); - wb.SaveAs(template.Path); - } - using (var wb = new XLWorkbook(template.Path)) - { - wb.SaveAs(workbook.Path); - } - using (var package = SpreadsheetDocument.Open(workbook.Path, false)) - { - Assert.AreEqual(SpreadsheetDocumentType.Workbook, package.DocumentType); - } + wb.AddWorksheet(); + wb.SaveAs(template.Path); + } + using (var wb = new XLWorkbook(template.Path)) + { + wb.SaveAs(workbook.Path); } + using var package = SpreadsheetDocument.Open(workbook.Path, false); + Assert.AreEqual(SpreadsheetDocumentType.Workbook, package.DocumentType); } [Test] public void SaveAsWithNoExtensionFails() { - using (var tf = new TemporaryFile("FileWithNoExtension")) - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add("Sheet1"); - TestDelegate action = () => wb.SaveAs(tf.Path); + using var tf = new TemporaryFile("FileWithNoExtension"); + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); + void action() => wb.SaveAs(tf.Path); - Assert.Throws(action); - } + Assert.Throws(action); } [Test] public void SaveAsWithUnsupportedExtensionFails() { - using (var tf = new TemporaryFile("FileWithBadExtension.bad")) - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add("Sheet1"); - TestDelegate action = () => wb.SaveAs(tf.Path); + using var tf = new TemporaryFile("FileWithBadExtension.bad"); + using var wb = new XLWorkbook(); + wb.Worksheets.Add("Sheet1"); + void action() => wb.SaveAs(tf.Path); - Assert.Throws(action); - } + Assert.Throws(action); } [Test] public void SaveCellValueWithLeadingQuotationMarkCorrectly() { var quotedFormulaValue = "'=IF(TRUE, 1, 0)"; - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var cell = ws.FirstCell(); - cell.SetValue(quotedFormulaValue); - Assert.IsFalse(cell.HasFormula); - Assert.AreEqual(quotedFormulaValue, cell.Value); + var ws = wb.AddWorksheet("Sheet1"); + var cell = ws.FirstCell(); + cell.SetValue(quotedFormulaValue); + Assert.IsFalse(cell.HasFormula); + Assert.AreEqual(quotedFormulaValue, cell.Value); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var cell = ws.FirstCell(); - Assert.IsFalse(cell.HasFormula); - Assert.AreEqual(quotedFormulaValue, cell.Value); - } + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var cell = ws.FirstCell(); + Assert.IsFalse(cell.HasFormula); + Assert.AreEqual(quotedFormulaValue, cell.Value); } } [Test] public void PreserveHeightOfEmptyRowsOnSaving() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.RowHeight = 50; - ws.Row(2).Height = 0; - ws.Row(3).Height = 20; - ws.Row(4).Height = 100; - - ws.CopyTo("Sheet2"); - wb.SaveAs(ms); - } + var ws = wb.AddWorksheet("Sheet1"); + ws.RowHeight = 50; + ws.Row(2).Height = 0; + ws.Row(3).Height = 20; + ws.Row(4).Height = 100; - ms.Seek(0, SeekOrigin.Begin); + ws.CopyTo("Sheet2"); + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) + ms.Seek(0, SeekOrigin.Begin); + + using (var wb = new XLWorkbook(ms)) + { + foreach (var sheetName in new[] { "Sheet1", "Sheet2" }) { - foreach (var sheetName in new[] { "Sheet1", "Sheet2" }) - { - var ws = wb.Worksheet(sheetName); + var ws = wb.Worksheet(sheetName); - Assert.AreEqual(50, ws.Row(1).Height); - Assert.AreEqual(0, ws.Row(2).Height); - Assert.AreEqual(20, ws.Row(3).Height); - Assert.AreEqual(100, ws.Row(4).Height); - } + Assert.AreEqual(50, ws.Row(1).Height); + Assert.AreEqual(0, ws.Row(2).Height); + Assert.AreEqual(20, ws.Row(3).Height); + Assert.AreEqual(100, ws.Row(4).Height); } } } @@ -491,32 +449,30 @@ public void PreserveHeightOfEmptyRowsOnSaving() [Test] public void PreserveWidthOfEmptyColumnsOnSaving() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Column(2).Width = 0; - ws.Column(3).Width = 20; - ws.Column(4).Width = 100; + var ws = wb.AddWorksheet("Sheet1"); + ws.Column(2).Width = 0; + ws.Column(3).Width = 20; + ws.Column(4).Width = 100; - ws.CopyTo("Sheet2"); - wb.SaveAs(ms); - } + ws.CopyTo("Sheet2"); + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) + using (var wb = new XLWorkbook(ms)) + { + foreach (var sheetName in new[] { "Sheet1", "Sheet2" }) { - foreach (var sheetName in new[] { "Sheet1", "Sheet2" }) - { - var ws = wb.Worksheet(sheetName); + var ws = wb.Worksheet(sheetName); - Assert.AreEqual(ws.ColumnWidth, ws.Column(1).Width); - Assert.AreEqual(0, ws.Column(2).Width); - Assert.AreEqual(20, ws.Column(3).Width); - Assert.AreEqual(100, ws.Column(4).Width); - } + Assert.AreEqual(ws.ColumnWidth, ws.Column(1).Width); + Assert.AreEqual(0, ws.Column(2).Width); + Assert.AreEqual(20, ws.Column(3).Width); + Assert.AreEqual(100, ws.Column(4).Width); } } } @@ -524,119 +480,110 @@ public void PreserveWidthOfEmptyColumnsOnSaving() [Test] public void PreserveAlignmentOnSaving() { - using (var input = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\HorizontalAlignment.xlsx"))) - using (var output = new MemoryStream()) + using var input = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\HorizontalAlignment.xlsx")); + using var output = new MemoryStream(); + using (var wb = new XLWorkbook(input)) { - using (var wb = new XLWorkbook(input)) - { - wb.SaveAs(output); - } + wb.SaveAs(output); + } - using (var wb = new XLWorkbook(output)) - { - Assert.AreEqual(XLAlignmentHorizontalValues.Center, wb.Worksheets.First().Cell("B1").Style.Alignment.Horizontal); - } + using (var wb = new XLWorkbook(output)) + { + Assert.AreEqual(XLAlignmentHorizontalValues.Center, wb.Worksheets.First().Cell("B1").Style.Alignment.Horizontal); } } [Test] public void PreserveMultipleColorScalesOnSaving() { - using (var output = new MemoryStream()) + using var output = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var sheet = wb.Worksheets.Add("test"); - sheet.Column(1).AddConditionalFormat().ColorScale().LowestValue(XLColor.Red) - .HighestValue(XLColor.Green); + var sheet = wb.Worksheets.Add("test"); + sheet.Column(1).AddConditionalFormat().ColorScale().LowestValue(XLColor.Red) + .HighestValue(XLColor.Green); - sheet.Column(2).AddConditionalFormat().ColorScale().LowestValue(XLColor.Alizarin) - .HighestValue(XLColor.Blue); + sheet.Column(2).AddConditionalFormat().ColorScale().LowestValue(XLColor.Alizarin) + .HighestValue(XLColor.Blue); - wb.SaveAs(output); - } + wb.SaveAs(output); + } - using (var wb = new XLWorkbook(output)) - { - var sheet = wb.Worksheets.First(); - var cf = sheet.ConditionalFormats - .OrderBy(x => x.Range.RangeAddress.FirstAddress.ColumnNumber) - .ToArray(); - Assert.AreEqual(2, cf.Length); - Assert.AreEqual(XLConditionalFormatType.ColorScale, cf[0].ConditionalFormatType); - Assert.AreEqual(XLColor.Red, cf[0].Colors[1]); - Assert.AreEqual(XLCFContentType.Minimum, cf[0].ContentTypes[1]); - Assert.AreEqual(XLColor.Green, cf[0].Colors[2]); - Assert.AreEqual(XLCFContentType.Maximum, cf[0].ContentTypes[2]); - Assert.AreEqual(XLConditionalFormatType.ColorScale, cf[1].ConditionalFormatType); - Assert.AreEqual(XLColor.Alizarin, cf[1].Colors[1]); - Assert.AreEqual(XLCFContentType.Minimum, cf[1].ContentTypes[1]); - Assert.AreEqual(XLColor.Blue, cf[1].Colors[2]); - Assert.AreEqual(XLCFContentType.Maximum, cf[1].ContentTypes[2]); - } + using (var wb = new XLWorkbook(output)) + { + var sheet = wb.Worksheets.First(); + var cf = sheet.ConditionalFormats + .OrderBy(x => x.Range.RangeAddress.FirstAddress.ColumnNumber) + .ToArray(); + Assert.AreEqual(2, cf.Length); + Assert.AreEqual(XLConditionalFormatType.ColorScale, cf[0].ConditionalFormatType); + Assert.AreEqual(XLColor.Red, cf[0].Colors[1]); + Assert.AreEqual(XLCFContentType.Minimum, cf[0].ContentTypes[1]); + Assert.AreEqual(XLColor.Green, cf[0].Colors[2]); + Assert.AreEqual(XLCFContentType.Maximum, cf[0].ContentTypes[2]); + Assert.AreEqual(XLConditionalFormatType.ColorScale, cf[1].ConditionalFormatType); + Assert.AreEqual(XLColor.Alizarin, cf[1].Colors[1]); + Assert.AreEqual(XLCFContentType.Minimum, cf[1].ContentTypes[1]); + Assert.AreEqual(XLColor.Blue, cf[1].Colors[2]); + Assert.AreEqual(XLCFContentType.Maximum, cf[1].ContentTypes[2]); } } [Test] public void RemoveExistingInlineStringsIfRequired() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlineStrings\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\InlineStrings\inputfile.xlsx")); + using var ms = new MemoryStream(); + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - var ws = wb.Worksheet(1); + var wb = new XLWorkbook(stream); + var ws = wb.Worksheet(1); - var numericCells = ws.CellsUsed(c => double.TryParse(c.GetString(), out double _)); - var textCells = ws.CellsUsed(c => !double.TryParse(c.GetString(), out double _)); + var numericCells = ws.CellsUsed(c => double.TryParse(c.GetString(), out var _)); + var textCells = ws.CellsUsed(c => !double.TryParse(c.GetString(), out var _)); - foreach (var cell in numericCells) - { - cell.Clear(XLClearOptions.AllFormats); - cell.SetDataType(XLDataType.Number); - } + foreach (var cell in numericCells) + { + cell.Clear(XLClearOptions.AllFormats); + cell.SetDataType(XLDataType.Number); + } - foreach (var cell in textCells) - { - cell.ShareString = true; - } + foreach (var cell in textCells) + { + cell.ShareString = true; + } - wb.SaveAs(ms); + wb.SaveAs(ms); - return wb; - }, @"Other\InlineStrings\outputfile.xlsx"); - } + return wb; + }, @"Other\InlineStrings\outputfile.xlsx"); } [Test] public void CanSaveFileWithEmptyFill() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyFill.xlsx"))) - using (var wb = new XLWorkbook(stream)) - using (var ms = new MemoryStream()) - { - Assert.DoesNotThrow(() => wb.SaveAs(ms, false)); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\EmptyFill.xlsx")); + using var wb = new XLWorkbook(stream); + using var ms = new MemoryStream(); + Assert.DoesNotThrow(() => wb.SaveAs(ms, false)); } [Test] public void CanSaveSingleRowAutoFilter() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SingleRowAutoFilter.xlsx"))) - using (var wb = new XLWorkbook(stream)) - using (var ms = new MemoryStream()) - { - Assert.DoesNotThrow(() => wb.SaveAs(ms, false)); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\SingleRowAutoFilter.xlsx")); + using var wb = new XLWorkbook(stream); + using var ms = new MemoryStream(); + Assert.DoesNotThrow(() => wb.SaveAs(ms, false)); } [Test] public void PivotTableWithVeryLongField() { + using var wb = new XLWorkbook(); + TestHelper.CreateAndCompare(() => { - var wb = new XLWorkbook(); var ws = wb.AddWorksheet(); var longText = string.Join(" ", Enumerable.Range(0, 40).Select(i => "1234567890")); @@ -661,12 +608,10 @@ public void PivotTableWithVeryLongField() public void CanSaveFileWithVml_NoComments() { //See #1285 - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithButton.xlsm"))) - using (var wb = new XLWorkbook(stream)) - using (var ms = new MemoryStream()) - { - Assert.DoesNotThrow(() => wb.SaveAs(ms)); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FileWithButton.xlsm")); + using var wb = new XLWorkbook(stream); + using var ms = new MemoryStream(); + Assert.DoesNotThrow(() => wb.SaveAs(ms)); } [Test] @@ -710,36 +655,32 @@ public void WorkbookFilterPrivacyIsNotSetByDefault() [Test] public void WorkbookFilterPrivacyIsReadCorrectly() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FilterPrivacyEnabledWorkbook.xlsx"))) - using (var wb = SpreadsheetDocument.Open(stream, false)) - { - Assert.IsTrue(wb.WorkbookPart.Workbook.WorkbookProperties.FilterPrivacy); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"TryToLoad\FilterPrivacyEnabledWorkbook.xlsx")); + using var wb = SpreadsheetDocument.Open(stream, false); + Assert.IsTrue(wb.WorkbookPart.Workbook.WorkbookProperties.FilterPrivacy); } [Test] public void CanSaveAsWithDataValidationAfterInsertFirstRowsAboveAndInsertFirstColumnsBefore() { - using (var wb = new XLWorkbook()) - using (var ms = new MemoryStream()) - { - var ws = wb.AddWorksheet("WithDataValidation"); - ws.Range("B4:B4").CreateDataValidation().WholeNumber.Between(0, 1); + using var wb = new XLWorkbook(); + using var ms = new MemoryStream(); + var ws = wb.AddWorksheet("WithDataValidation"); + ws.Range("B4:B4").CreateDataValidation().WholeNumber.Between(0, 1); - ws.Row(1).InsertRowsAbove(1); - var dv = ws.DataValidations.ToArray(); - Assert.AreEqual(1, dv.Length); - Assert.AreEqual("B5:B5", dv[0].Ranges.Single().RangeAddress.ToString()); + ws.Row(1).InsertRowsAbove(1); + var dv = ws.DataValidations.ToArray(); + Assert.AreEqual(1, dv.Length); + Assert.AreEqual("B5:B5", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.DoesNotThrow(() => wb.SaveAs(ms)); + Assert.DoesNotThrow(() => wb.SaveAs(ms)); - ws.Column(1).InsertColumnsBefore(1); - dv = ws.DataValidations.ToArray(); - Assert.AreEqual(1, dv.Length); - Assert.AreEqual("C5:C5", dv[0].Ranges.Single().RangeAddress.ToString()); + ws.Column(1).InsertColumnsBefore(1); + dv = ws.DataValidations.ToArray(); + Assert.AreEqual(1, dv.Length); + Assert.AreEqual("C5:C5", dv[0].Ranges.Single().RangeAddress.ToString()); - Assert.DoesNotThrow(() => wb.SaveAs(ms)); - } + Assert.DoesNotThrow(() => wb.SaveAs(ms)); } // https://github.com/ClosedXML/ClosedXML/issues/1606 @@ -770,4 +711,4 @@ public void CanSaveFileToDefaultDirectory() } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Sparklines/SparklinesTests.cs b/ClosedXML.Tests/Excel/Sparklines/SparklinesTests.cs index 7066f94c3..dc57fb0c4 100644 --- a/ClosedXML.Tests/Excel/Sparklines/SparklinesTests.cs +++ b/ClosedXML.Tests/Excel/Sparklines/SparklinesTests.cs @@ -15,38 +15,38 @@ public class SparklinesTests [Test] public void CannotCreateSparklineGroupsWithoutWorksheet() { - TestDelegate action = () => new XLSparklineGroups(null); + static void action() => new XLSparklineGroups(null); Assert.Throws(action); } [Test] public void CannotCreateSparklineGroupWithoutWorksheet() { - TestDelegate action = () => new XLSparklineGroup(null); + static void action() => new XLSparklineGroup(null); Assert.Throws(action); } [Test] public void CannotCreateSparklineWithoutGroup() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); - TestDelegate action = () => new XLSparkline(null, ws.Cell("A1"), ws.Range("A2:A5")); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); + void action() => new XLSparkline(null, ws.Cell("A1"), ws.Range("A2:A5")); Assert.Throws(action); } [Test] public void CannotCreateSparklineWithoutLocation() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var group = new XLSparklineGroup(ws); - TestDelegate action = () => new XLSparkline(group, null, ws.Range("A2:A5")); + void action() => new XLSparkline(group, null, ws.Range("A2:A5")); Assert.Throws(action); } [Test] public void CanCreateInvalidSparklineWithoutSourceData() { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet1"); var group = new XLSparklineGroup(ws); var sparkline = new XLSparkline(group, ws.FirstCell(), null); Assert.IsFalse(sparkline.IsValid); @@ -55,7 +55,7 @@ public void CanCreateInvalidSparklineWithoutSourceData() [Test] public void CanAddSparklineGroupForSingleCell() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add(new XLSparklineGroup(ws, "A1", "B1:E1")); ws.SparklineGroups.Add("A2", "B2:E2"); @@ -77,7 +77,7 @@ public void CanAddSparklineGroupForSingleCell() [Test] public void CanAddSparklineGroupForVerticalRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add(ws.Range("A1:A3"), ws.Range("B1:E3")); @@ -95,7 +95,7 @@ public void CanAddSparklineGroupForVerticalRange() [Test] public void CanAddSparklineGroupForHorizontalRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add(ws.Range("A1:C1"), ws.Range("A2:C4")); @@ -113,9 +113,9 @@ public void CanAddSparklineGroupForHorizontalRange() [Test] public void CannotAddSparklineForNonLinearRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); - TestDelegate action = () => ws.SparklineGroups.Add(ws.Range("A1:C2"), ws.Range("A3:C4")); + void action() => ws.SparklineGroups.Add(ws.Range("A1:C2"), ws.Range("A3:C4")); var message = Assert.Throws(action).Message; Assert.AreEqual("locationRange must have either a single row or a single column", message); @@ -124,9 +124,9 @@ public void CannotAddSparklineForNonLinearRange() [Test] public void CannotAddSparklineWhenRangesHaveDifferentWidths() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); - TestDelegate action = () => ws.SparklineGroups.Add(ws.Range("A1:C1"), ws.Range("A3:D4")); + void action() => ws.SparklineGroups.Add(ws.Range("A1:C1"), ws.Range("A3:D4")); var message = Assert.Throws(action).Message; Assert.AreEqual("locationRange and sourceDataRange must have the same width", message); @@ -135,9 +135,9 @@ public void CannotAddSparklineWhenRangesHaveDifferentWidths() [Test] public void CannotAddSparklineWhenRangesHaveDifferentHeights() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); - TestDelegate action = () => ws.SparklineGroups.Add(ws.Range("A1:A3"), ws.Range("B1:B4")); + void action() => ws.SparklineGroups.Add(ws.Range("A1:A3"), ws.Range("B1:B4")); var message = Assert.Throws(action).Message; Assert.AreEqual("locationRange and sourceDataRange must have the same height", message); @@ -146,9 +146,9 @@ public void CannotAddSparklineWhenRangesHaveDifferentHeights() [Test] public void CannotAddSparklineForCellWhenDataRangeIsNotLinear() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); - TestDelegate action = () => ws.SparklineGroups.Add(ws.Range("A1:A1"), ws.Range("B1:C4")); + void action() => ws.SparklineGroups.Add(ws.Range("A1:A1"), ws.Range("B1:C4")); var message = Assert.Throws(action).Message; Assert.AreEqual("SourceData range must have either a single row or a single column", message); @@ -157,12 +157,13 @@ public void CannotAddSparklineForCellWhenDataRangeIsNotLinear() [Test] public void CanAddSparklineToExistingGroup() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); - var group = new XLSparklineGroup(ws); - - group.Add("A2", "B2:E2"); - group.Add(ws.Cell("A3"), ws.Range("B3:E3")); + var group = new XLSparklineGroup(ws) + { + { "A2", "B2:E2" }, + { ws.Cell("A3"), ws.Range("B3:E3") } + }; Assert.AreEqual(0, ws.SparklineGroups.Count()); @@ -176,13 +177,13 @@ public void CanAddSparklineToExistingGroup() [Test] public void CannotAddSparklineGroupFromDifferentWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var group = new XLSparklineGroup(ws1); - TestDelegate action = () => ws2.SparklineGroups.Add(group); + void action() => ws2.SparklineGroups.Add(group); var message = Assert.Throws(action).Message; Assert.AreEqual("The specified sparkline group belongs to the different worksheet", message); @@ -191,13 +192,13 @@ public void CannotAddSparklineGroupFromDifferentWorksheet() [Test] public void CannotAddSparklineFromDifferentWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var group = new XLSparklineGroup(ws1); - TestDelegate action = () => group.Add(ws2.Cell("A3"), ws1.Range("B3:E3")); + void action() => group.Add(ws2.Cell("A3"), ws1.Range("B3:E3")); var message = Assert.Throws(action).Message; Assert.AreEqual("The specified sparkline belongs to the different worksheet", message); @@ -206,7 +207,7 @@ public void CannotAddSparklineFromDifferentWorksheet() [Test] public void AddSparklineToSameCellOverwritesItWhenSameGroup() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1", "B1:E1"); group.Add("A1", "B2:E2"); @@ -220,7 +221,7 @@ public void AddSparklineToSameCellOverwritesItWhenSameGroup() [Test] public void AddSparklineToSameCellOverwritesItWhenDifferentGroup() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1", "B1:E1"); ws.SparklineGroups.Add("A1", "B2:E2"); @@ -234,7 +235,7 @@ public void AddSparklineToSameCellOverwritesItWhenDifferentGroup() [Test] public void CanAddSparklineReferringToDifferentWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws3 = wb.AddWorksheet("Sheet 3"); @@ -255,7 +256,7 @@ public void CanAddSparklineReferringToDifferentWorksheet() [TestCase("Z1", "Z2:Z100")] public void CanGetSparklineForExistingCell(string cellAddress, string expectedSourceDataRange) { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A2:A100", "B2:Z100"); ws.SparklineGroups.Add("B1:Z1", "B2:Z100"); @@ -272,7 +273,7 @@ public void CanGetSparklineForExistingCell(string cellAddress, string expectedSo [TestCase("AA1")] public void CannotGetSparklineForNonExistingCell(string cellAddress) { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A2:A100", "B2:Z100"); ws.SparklineGroups.Add("B1:Z1", "B2:Z100"); @@ -284,7 +285,7 @@ public void CannotGetSparklineForNonExistingCell(string cellAddress) [Test] public void CanGetSparklinesForRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A2:A100", "B2:Z100"); ws.SparklineGroups.Add("B1:Z1", "B2:Z100"); @@ -314,7 +315,7 @@ public void CanGetSparklinesForRange() [Test] public void CanRemoveSparklineFromCell() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A3", "B1:Z3"); ws.SparklineGroups.Remove(ws.Cell("A2")); @@ -330,7 +331,7 @@ public void CanRemoveSparklineFromCell() [Test] public void CanRemoveSparklineFromRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A5", "B1:Z5"); ws.SparklineGroups.Remove(ws.Range("A2:D4")); @@ -346,7 +347,7 @@ public void CanRemoveSparklineFromRange() [Test] public void RemoveSparklineFromEmptyCellDoesNothing() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A2", "B1:Z2"); ws.SparklineGroups.Remove(ws.Cell("F2")); @@ -366,7 +367,7 @@ public void RemoveSparklineFromEmptyCellDoesNothing() [Test] public void CanChangeSparklineLocationInsideWorksheet() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A2", "B1:Z2"); ws.SparklineGroups.Single().Last().SetLocation(ws.Cell("F2")); @@ -385,7 +386,7 @@ public void CanChangeSparklineLocationInsideWorksheet() [Test] public void ChangeSparklineLocationOverwritesExistingSparklineSameGroup() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A2", "B1:Z2"); ws.SparklineGroups.Single().Last().SetLocation(ws.Cell("A1")); @@ -399,7 +400,7 @@ public void ChangeSparklineLocationOverwritesExistingSparklineSameGroup() [Test] public void ChangeSparklineLocationOverwritesExistingSparklineDifferentGroups() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A2", "B1:Z2"); ws.SparklineGroups.Add("A3", "B3:Z3"); @@ -417,13 +418,13 @@ public void ChangeSparklineLocationOverwritesExistingSparklineDifferentGroups() [Test] public void CannotChangeSparklineLocationToAnotherWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var group = ws1.SparklineGroups.Add("A1:A2", "B1:Z2"); - TestDelegate action = () => group.First().SetLocation(ws2.FirstCell()); + void action() => group.First().SetLocation(ws2.FirstCell()); var message = Assert.Throws(action).Message; Assert.AreEqual("Cannot move the sparkline to a different worksheet", message); @@ -432,7 +433,7 @@ public void CannotChangeSparklineLocationToAnotherWorksheet() [Test] public void CanChangeSparklineSourceDataInsideWorksheet() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A2", "B1:Z2"); ws.SparklineGroups.Single().Last().SetSourceData(ws.Range("D4:D50")); @@ -448,11 +449,11 @@ public void CanChangeSparklineSourceDataInsideWorksheet() [Test] public void CannotChangeSparklineSourceDataToNonLinearRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1", "B1:Z1"); var sparkline = group.Single(); - TestDelegate action = () => sparkline.SetSourceData(ws.Range("B1:Z2")); + void action() => sparkline.SetSourceData(ws.Range("B1:Z2")); var message = Assert.Throws(action).Message; Assert.AreEqual("SourceData range must have either a single row or a single column", message); @@ -461,7 +462,7 @@ public void CannotChangeSparklineSourceDataToNonLinearRange() [Test] public void CanChangeSparklineStyle() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1", "B1:Z1"); group.Style = XLSparklineTheme.Colorful1; @@ -478,7 +479,7 @@ public void CanChangeSparklineStyle() [Test] public void ChangeSparklineStyleDoesNotAffectOriginal() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1", "B1:Z1"); group.Style = XLSparklineTheme.Colorful1; @@ -491,10 +492,10 @@ public void ChangeSparklineStyleDoesNotAffectOriginal() [Test] public void CannotSetSparklineStyleToNull() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1", "B1:Z1"); - TestDelegate action = () => group.Style = null; + void action() => group.Style = null; Assert.Throws(action); } @@ -502,7 +503,7 @@ public void CannotSetSparklineStyleToNull() [Test] public void SparklinesShiftOnRowInsert() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group1 = ws.SparklineGroups.Add("B2", "D4:F4"); var group2 = ws.SparklineGroups.Add("B3", "D4:D8"); var group3 = ws.SparklineGroups.Add("B4", "E1:E8"); @@ -520,7 +521,7 @@ public void SparklinesShiftOnRowInsert() [Test] public void SparklinesShiftOnRowDelete() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group1 = ws.SparklineGroups.Add("B2", "D7:F7"); var group2 = ws.SparklineGroups.Add("B6", "D7:D11"); var group3 = ws.SparklineGroups.Add("B7", "E1:E11"); @@ -538,7 +539,7 @@ public void SparklinesShiftOnRowDelete() [Test] public void SparklinesShiftOnColumnInsert() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group1 = ws.SparklineGroups.Add("B2", "D4:F4"); var group2 = ws.SparklineGroups.Add("C3", "D4:D8"); var group3 = ws.SparklineGroups.Add("D4", "A4:E4"); @@ -556,7 +557,7 @@ public void SparklinesShiftOnColumnInsert() [Test] public void SparklinesShiftOnColumnDelete() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group1 = ws.SparklineGroups.Add("B2", "G4:I4"); var group2 = ws.SparklineGroups.Add("F3", "G4:G8"); var group3 = ws.SparklineGroups.Add("G4", "A4:H4"); @@ -574,7 +575,7 @@ public void SparklinesShiftOnColumnDelete() [Test] public void SparklineRemovedWhenColumnDeleted() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:B1", "C2:D6"); ws.Column(2).Delete(); @@ -587,7 +588,7 @@ public void SparklineRemovedWhenColumnDeleted() [Test] public void SparklineRemovedWhenRowDeleted() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:A2", "C3:F4"); ws.Row(2).Delete(); @@ -600,7 +601,7 @@ public void SparklineRemovedWhenRowDeleted() [Test] public void SparklineRemovedWhenShiftedTooFarRight() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("XFD1", "A1:Z1"); ws.Column(1).InsertColumnsBefore(1); @@ -611,7 +612,7 @@ public void SparklineRemovedWhenShiftedTooFarRight() [Test] public void SparklineRemovedWhenShiftedTooFarDown() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1048576", "A1:Z1"); ws.Row(1).InsertRowsAbove(1); @@ -622,7 +623,7 @@ public void SparklineRemovedWhenShiftedTooFarDown() [Test] public void SparklineRangeInvalidatedWhenDeleted() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:B1", "C2:D6"); ws.Column(4).Delete(); @@ -727,8 +728,8 @@ void AssertGroupIsValid(IXLSparklineGroup group) Assert.IsTrue(group.HorizontalAxis.RightToLeft); Assert.IsTrue(group.HorizontalAxis.DateAxis); - Assert.AreEqual(6.6, group.VerticalAxis.ManualMax, XLHelper.Epsilon); - Assert.AreEqual(1.2, group.VerticalAxis.ManualMin, XLHelper.Epsilon); + Assert.That(group.VerticalAxis.ManualMax, Is.EqualTo(6.6)); + Assert.That(group.VerticalAxis.ManualMin, Is.EqualTo(1.2)); Assert.AreEqual(XLSparklineAxisMinMax.Custom, group.VerticalAxis.MaxAxisType); Assert.AreEqual(XLSparklineAxisMinMax.Custom, group.VerticalAxis.MinAxisType); } @@ -737,11 +738,9 @@ void AssertGroupIsValid(IXLSparklineGroup group) [Test] public void CanLoadSparklines() { - using (var ms = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Sparklines\SparklineThemes\inputfile.xlsx"))) - using (var wb = new XLWorkbook(ms)) - { - Assert.IsTrue(wb.Worksheets.All(ws => ws.SparklineGroups.Count() == 6)); - } + using var ms = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Sparklines\SparklineThemes\inputfile.xlsx")); + using var wb = new XLWorkbook(ms); + Assert.IsTrue(wb.Worksheets.All(ws => ws.SparklineGroups.Count() == 6)); } [TestCase("Accent!B1", nameof(XLSparklineTheme.Accent1))] @@ -802,80 +801,74 @@ IXLSparklineStyle GetThemeByName(string themeName) [Test] public void DeletedSparklinesRemovedFromFile() { - using (var input = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Sparklines\SparklineThemes\inputfile.xlsx"))) - using (var output = new MemoryStream()) + using var input = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\Sparklines\SparklineThemes\inputfile.xlsx")); + using var output = new MemoryStream(); + using (var wb = new XLWorkbook(input)) { - using (var wb = new XLWorkbook(input)) - { - wb.Worksheet(1).SparklineGroups.RemoveAll(); - wb.Worksheet(2).SparklineGroups.Remove(wb.Worksheet(2).Cell("B1")); - wb.Worksheet(3).SparklineGroups.Remove(wb.Worksheet(3).Range("B2:B6")); - wb.Worksheet(4).SparklineGroups.Remove(wb.Worksheet(4).SparklineGroups.First()); + wb.Worksheet(1).SparklineGroups.RemoveAll(); + wb.Worksheet(2).SparklineGroups.Remove(wb.Worksheet(2).Cell("B1")); + wb.Worksheet(3).SparklineGroups.Remove(wb.Worksheet(3).Range("B2:B6")); + wb.Worksheet(4).SparklineGroups.Remove(wb.Worksheet(4).SparklineGroups.First()); - wb.SaveAs(output); - } + wb.SaveAs(output); + } - using (var wb = new XLWorkbook(output)) - { - Assert.AreEqual(0, wb.Worksheet(1).SparklineGroups.Count()); - Assert.AreEqual(5, wb.Worksheet(2).SparklineGroups.Count()); - Assert.AreEqual(1, wb.Worksheet(3).SparklineGroups.Count()); - Assert.AreEqual(5, wb.Worksheet(4).SparklineGroups.Count()); - Assert.AreEqual(6, wb.Worksheet(5).SparklineGroups.Count()); - Assert.AreEqual(6, wb.Worksheet(6).SparklineGroups.Count()); - } + using (var wb = new XLWorkbook(output)) + { + Assert.AreEqual(0, wb.Worksheet(1).SparklineGroups.Count()); + Assert.AreEqual(5, wb.Worksheet(2).SparklineGroups.Count()); + Assert.AreEqual(1, wb.Worksheet(3).SparklineGroups.Count()); + Assert.AreEqual(5, wb.Worksheet(4).SparklineGroups.Count()); + Assert.AreEqual(6, wb.Worksheet(5).SparklineGroups.Count()); + Assert.AreEqual(6, wb.Worksheet(6).SparklineGroups.Count()); } } [Test] public void EmptySparklineGroupsSkippedOnSaving() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet 1"); - var group = ws.SparklineGroups.Add("A1:A2", "B1:Z2"); + var ws = wb.AddWorksheet("Sheet 1"); + var group = ws.SparklineGroups.Add("A1:A2", "B1:Z2"); - group.RemoveAll(); + group.RemoveAll(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual(0, wb.Worksheets.First().SparklineGroups.Count()); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual(0, wb.Worksheets.First().SparklineGroups.Count()); } } [Test] public void CanSaveAndLoadSparklineWithInvalidRange() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet 1"); - var ws2 = wb.AddWorksheet("Sheet 2"); + var ws1 = wb.AddWorksheet("Sheet 1"); + var ws2 = wb.AddWorksheet("Sheet 2"); - ws1.SparklineGroups.Add("A1:A3", "'Sheet 2'!B1:F3"); - ws1.SparklineGroups.Add("A4:A6", "B4:F6") - .SetDateRange(ws2.Range("A1:E1")); + ws1.SparklineGroups.Add("A1:A3", "'Sheet 2'!B1:F3"); + ws1.SparklineGroups.Add("A4:A6", "B4:F6") + .SetDateRange(ws2.Range("A1:E1")); - ws2.Delete(); - wb.SaveAs(ms); - } + ws2.Delete(); + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.Single(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.Single(); - Assert.AreEqual(2, ws.SparklineGroups.Count()); - Assert.IsFalse(ws.Cell("A2").Sparkline.IsValid); - Assert.AreEqual("B5:F5", ws.Cell("A5").Sparkline.SourceData.RangeAddress.ToString()); - Assert.IsNull(ws.Cell("A5").Sparkline.SparklineGroup.DateRange); - } + Assert.AreEqual(2, ws.SparklineGroups.Count()); + Assert.IsFalse(ws.Cell("A2").Sparkline.IsValid); + Assert.AreEqual("B5:F5", ws.Cell("A5").Sparkline.SourceData.RangeAddress.ToString()); + Assert.IsNull(ws.Cell("A5").Sparkline.SparklineGroup.DateRange); } } @@ -886,28 +879,28 @@ public void CanSaveAndLoadSparklineWithInvalidRange() [Test] public void SetManualMinChangesAxisTypeToCustom() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var axis = ws.SparklineGroups.Add("A1:A2", "B1:Z2") .VerticalAxis .SetMinAxisType(XLSparklineAxisMinMax.SameForAll); axis.ManualMin = 100; - Assert.AreEqual(100, axis.ManualMin, XLHelper.Epsilon); + Assert.That(axis.ManualMin, Is.EqualTo(100)); Assert.AreEqual(XLSparklineAxisMinMax.Custom, axis.MinAxisType); } [Test] public void SetManualMaxChangesAxisTypeToCustom() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var axis = ws.SparklineGroups.Add("A1:A2", "B1:Z2") .VerticalAxis .SetMaxAxisType(XLSparklineAxisMinMax.SameForAll); axis.ManualMax = 100; - Assert.AreEqual(100, axis.ManualMax, XLHelper.Epsilon); + Assert.That(axis.ManualMax, Is.EqualTo(100)); Assert.AreEqual(XLSparklineAxisMinMax.Custom, axis.MaxAxisType); } @@ -916,7 +909,7 @@ public void SetManualMaxChangesAxisTypeToCustom() [TestCase(XLSparklineAxisMinMax.Automatic, null)] public void SetAxisTypeToNonCustomSetsManualMinToNull(XLSparklineAxisMinMax axisType, double? expectedManualMin) { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var axis = ws.SparklineGroups.Add("A1", "B1:Z1") .VerticalAxis .SetManualMin(100); @@ -924,9 +917,13 @@ public void SetAxisTypeToNonCustomSetsManualMinToNull(XLSparklineAxisMinMax axis axis.MinAxisType = axisType; if (expectedManualMin.HasValue) + { Assert.AreEqual(expectedManualMin.Value, axis.ManualMin.Value, XLHelper.Epsilon); + } else + { Assert.IsNull(axis.ManualMin); + } } [TestCase(XLSparklineAxisMinMax.Custom, 100)] @@ -934,7 +931,7 @@ public void SetAxisTypeToNonCustomSetsManualMinToNull(XLSparklineAxisMinMax axis [TestCase(XLSparklineAxisMinMax.Automatic, null)] public void SetAxisTypeToNonCustomSetsManualMaxToNull(XLSparklineAxisMinMax axisType, double? expectedManualMax) { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var axis = ws.SparklineGroups.Add("A1", "B1:Z1") .VerticalAxis .SetManualMax(100); @@ -942,15 +939,19 @@ public void SetAxisTypeToNonCustomSetsManualMaxToNull(XLSparklineAxisMinMax axis axis.MaxAxisType = axisType; if (expectedManualMax.HasValue) + { Assert.AreEqual(expectedManualMax.Value, axis.ManualMax.Value, XLHelper.Epsilon); + } else + { Assert.IsNull(axis.ManualMax); + } } [Test] public void SetDateRangeChangesAxisType() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:A2", "B1:Z2"); group.DateRange = ws.Range("B3:Z3"); @@ -961,7 +962,7 @@ public void SetDateRangeChangesAxisType() [Test] public void SetDateRangeToNullChangesAxisType() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:A2", "B1:Z2"); group.DateRange = ws.Range("B3:Z3"); @@ -973,10 +974,10 @@ public void SetDateRangeToNullChangesAxisType() [Test] public void CannotSetNonLinearDateRange() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); var group = ws.SparklineGroups.Add("A1:A2", "B1:Z2"); - TestDelegate action = () => group.DateRange = ws.Range("B3:Z4"); + void action() => group.DateRange = ws.Range("B3:Z4"); Assert.Throws(action); } @@ -988,7 +989,7 @@ public void CannotSetNonLinearDateRange() [Test] public void CopyCellToSameWorksheetCopiesSparkline() { - var ws = new XLWorkbook().AddWorksheet("Sheet 1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.AddWorksheet("Sheet 1"); ws.SparklineGroups.Add("A1:A3", "B1:F3"); var target = ws.Cell("D4"); @@ -1003,7 +1004,7 @@ public void CopyCellToSameWorksheetCopiesSparkline() [Test] public void CopyCellToDifferentWorksheetCopiesSparklineGroup() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var ws3 = wb.AddWorksheet("Sheet 3"); @@ -1026,7 +1027,7 @@ public void CopyCellToDifferentWorksheetCopiesSparklineGroup() [Test] public void CopySparklineIfDateRangeOnSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var group = ws1.SparklineGroups.Add("A1:A3", "B1:F3"); @@ -1044,7 +1045,7 @@ public void CopySparklineIfDateRangeOnSameWorksheet() [Test] public void CopySparklineIfDateRangeSourceOnDifferentWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.AddWorksheet("Sheet 1"); var ws2 = wb.AddWorksheet("Sheet 2"); var ws3 = wb.AddWorksheet("Sheet 3"); @@ -1072,4 +1073,4 @@ public void CreateSampleSparklines() #endregion Test Examples } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Styles/BorderTests.cs b/ClosedXML.Tests/Excel/Styles/BorderTests.cs index d194bee26..a75de22fb 100644 --- a/ClosedXML.Tests/Excel/Styles/BorderTests.cs +++ b/ClosedXML.Tests/Excel/Styles/BorderTests.cs @@ -8,29 +8,27 @@ public class BorderTests [Test] public void SetInsideBorderPreservesOutsideBorders() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); - ws.Cells("B2:C2").Style - .Border.SetOutsideBorder(XLBorderStyleValues.Thin) - .Border.SetOutsideBorderColor(XLColor.FromTheme(XLThemeColor.Accent1, 0.5)); + ws.Cells("B2:C2").Style + .Border.SetOutsideBorder(XLBorderStyleValues.Thin) + .Border.SetOutsideBorderColor(XLColor.FromTheme(XLThemeColor.Accent1, 0.5)); - //Check pre-conditions - Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.LeftBorder); - Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.RightBorder); - Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.LeftBorderColor.ThemeColor); - Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.RightBorderColor.ThemeColor); + //Check pre-conditions + Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.LeftBorder); + Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.RightBorder); + Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.LeftBorderColor.ThemeColor); + Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.RightBorderColor.ThemeColor); - ws.Range("B2:C2").Style.Border.SetInsideBorder(XLBorderStyleValues.None); + ws.Range("B2:C2").Style.Border.SetInsideBorder(XLBorderStyleValues.None); - Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.LeftBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.LeftBorder); - Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("C2").Style.Border.RightBorder); - Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.LeftBorderColor.ThemeColor); - Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("C2").Style.Border.RightBorderColor.ThemeColor); - } + Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("B2").Style.Border.LeftBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("B2").Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.None, ws.Cell("C2").Style.Border.LeftBorder); + Assert.AreEqual(XLBorderStyleValues.Thin, ws.Cell("C2").Style.Border.RightBorder); + Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("B2").Style.Border.LeftBorderColor.ThemeColor); + Assert.AreEqual(XLThemeColor.Accent1, ws.Cell("C2").Style.Border.RightBorderColor.ThemeColor); } } } diff --git a/ClosedXML.Tests/Excel/Styles/ColorTests.cs b/ClosedXML.Tests/Excel/Styles/ColorTests.cs index eaaf0bd23..e519ac9f1 100644 --- a/ClosedXML.Tests/Excel/Styles/ColorTests.cs +++ b/ClosedXML.Tests/Excel/Styles/ColorTests.cs @@ -2,10 +2,10 @@ using ClosedXML.Utils; using DocumentFormat.OpenXml.Spreadsheet; using NUnit.Framework; -using Color = System.Drawing.Color; +using SkiaSharp; using X14 = DocumentFormat.OpenXml.Office2010.Excel; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Styles { [TestFixture] public class ColorTests @@ -25,18 +25,18 @@ public void ColorNotEqualOperatorInPlace() [Test] public void ColorNamedVsHTML() { - Assert.IsTrue(XLColor.Black == XLColor.FromHtml("#000000")); + Assert.That(XLColor.Black, Is.EqualTo(XLColor.FromHtml("#FF000000"))); } [Test] public void DefaultColorIndex64isTransparentWhite() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - XLColor color = ws.FirstCell().Style.Fill.BackgroundColor; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var color = ws.FirstCell().Style.Fill.BackgroundColor; Assert.AreEqual(XLColorType.Indexed, color.ColorType); Assert.AreEqual(64, color.Indexed); - Assert.AreEqual(Color.Transparent, color.Color); + Assert.AreEqual(SKColors.Transparent, color.Color); } [Test] @@ -171,4 +171,4 @@ public void CanConvertX14ColorTypeToXlColor() Assert.AreEqual(0.4, xlColor4.ThemeTint, XLHelper.Epsilon); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Styles/NumberFormatTests.cs b/ClosedXML.Tests/Excel/Styles/NumberFormatTests.cs index 2d4e44346..216cf2a83 100644 --- a/ClosedXML.Tests/Excel/Styles/NumberFormatTests.cs +++ b/ClosedXML.Tests/Excel/Styles/NumberFormatTests.cs @@ -5,71 +5,65 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Styles { public class NumberFormatTests { [Test] public void PreserveCellFormat() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var table = new DataTable(); - table.Columns.Add("Date", typeof(DateTime)); + using var table = new DataTable(); + table.Columns.Add("Date", typeof(DateTime)); - for (int i = 0; i < 10; i++) - { - table.Rows.Add(new DateTime(2017, 1, 1).AddMonths(i)); - } + for (var i = 0; i < 10; i++) + { + table.Rows.Add(new DateTime(2017, 1, 1).AddMonths(i)); + } - ws.Column(1).Style.NumberFormat.Format = "yy-MM-dd"; - ws.Cell("A1").InsertData(table); - Assert.AreEqual("yy-MM-dd", ws.Cell("A5").Style.DateFormat.Format); + ws.Column(1).Style.NumberFormat.Format = "yy-MM-dd"; + ws.Cell("A1").InsertData(table); + Assert.AreEqual("yy-MM-dd", ws.Cell("A5").Style.DateFormat.Format); - ws.Row(1).Style.NumberFormat.Format = "yy-MM-dd"; - ws.Cell("A1").InsertData(table.Rows, true); - Assert.AreEqual("yy-MM-dd", ws.Cell("E1").Style.DateFormat.Format); - } + ws.Row(1).Style.NumberFormat.Format = "yy-MM-dd"; + ws.Cell("A1").InsertData(table.Rows, true); + Assert.AreEqual("yy-MM-dd", ws.Cell("E1").Style.DateFormat.Format); } [Test] public void TestExcelNumberFormats() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var c = ws.FirstCell() - .SetValue(41573.875) - .SetDataType(XLDataType.DateTime); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var c = ws.FirstCell() + .SetValue(41573.875) + .SetDataType(XLDataType.DateTime); - c.Style.NumberFormat.SetFormat("m/d/yy\\ h:mm;@"); + c.Style.NumberFormat.SetFormat("m/d/yy\\ h:mm;@"); - Assert.AreEqual("10/26/13 21:00", c.GetFormattedString()); - } + Assert.AreEqual("10/26/13 21:00", c.GetFormattedString()); } [Test] public void ReadAndWriteColumnNumberFormat() { - using (var memoryStream = new MemoryStream()) + using var memoryStream = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var sourceColumn = ws.Column(1); - sourceColumn.Style.NumberFormat.Format = "0.000"; - wb.SaveAs(memoryStream); - } + var ws = wb.AddWorksheet(); + var sourceColumn = ws.Column(1); + sourceColumn.Style.NumberFormat.Format = "0.000"; + wb.SaveAs(memoryStream); + } - memoryStream.Position = 0; + memoryStream.Position = 0; - using (var wb = new XLWorkbook(memoryStream)) - { - var column = wb.Worksheets.Single().Column(1); - Assert.AreEqual("0.000", column.Style.NumberFormat.Format); - } + using (var wb = new XLWorkbook(memoryStream)) + { + var column = wb.Worksheets.Single().Column(1); + Assert.AreEqual("0.000", column.Style.NumberFormat.Format); } } @@ -91,4 +85,4 @@ public void XLNumberFormatKey_Equals_IsCaseSensitive() Assert.IsFalse(numberFormatKey1.Equals(numberFormatKey2)); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Styles/StyleChangeTests.cs b/ClosedXML.Tests/Excel/Styles/StyleChangeTests.cs index a67ea74eb..749336c9e 100644 --- a/ClosedXML.Tests/Excel/Styles/StyleChangeTests.cs +++ b/ClosedXML.Tests/Excel/Styles/StyleChangeTests.cs @@ -9,46 +9,44 @@ public class StyleChangeTests [Test] public void ChangeFontColorDoesNotAffectOtherProperties() { - using (var wb = new XLWorkbook()) - { - // Arrange - var ws = wb.AddWorksheet("Sheet1"); - var a1 = ws.Cell("A1"); - var a2 = ws.Cell("A2"); - var b1 = ws.Cell("B1"); - var b2 = ws.Cell("B2"); - - ws.Range("A1:B2").Value = "Test"; - - a1.Style.Fill.BackgroundColor = XLColor.Red; - a2.Style.Fill.BackgroundColor = XLColor.Green; - b1.Style.Fill.BackgroundColor = XLColor.Blue; - b2.Style.Fill.BackgroundColor = XLColor.Pink; - - a1.Style.Font.FontName = "Arial"; - a2.Style.Font.FontName = "Times New Roman"; - b1.Style.Font.FontName = "Calibri"; - b2.Style.Font.FontName = "Cambria"; - - // Act - ws.Range("A1:B2").Style.Font.FontColor = XLColor.PowderBlue; - - //Assert - Assert.AreEqual(XLColor.Red, ws.Cell("A1").Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Cell("A2").Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Blue, ws.Cell("B1").Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Pink, ws.Cell("B2").Style.Fill.BackgroundColor); - - Assert.AreEqual("Arial", ws.Cell("A1").Style.Font.FontName); - Assert.AreEqual("Times New Roman", ws.Cell("A2").Style.Font.FontName); - Assert.AreEqual("Calibri", ws.Cell("B1").Style.Font.FontName); - Assert.AreEqual("Cambria", ws.Cell("B2").Style.Font.FontName); - - Assert.AreEqual(XLColor.PowderBlue, ws.Cell("A1").Style.Font.FontColor); - Assert.AreEqual(XLColor.PowderBlue, ws.Cell("A2").Style.Font.FontColor); - Assert.AreEqual(XLColor.PowderBlue, ws.Cell("B1").Style.Font.FontColor); - Assert.AreEqual(XLColor.PowderBlue, ws.Cell("B2").Style.Font.FontColor); - } + using var wb = new XLWorkbook(); + // Arrange + var ws = wb.AddWorksheet("Sheet1"); + var a1 = ws.Cell("A1"); + var a2 = ws.Cell("A2"); + var b1 = ws.Cell("B1"); + var b2 = ws.Cell("B2"); + + ws.Range("A1:B2").Value = "Test"; + + a1.Style.Fill.BackgroundColor = XLColor.Red; + a2.Style.Fill.BackgroundColor = XLColor.Green; + b1.Style.Fill.BackgroundColor = XLColor.Blue; + b2.Style.Fill.BackgroundColor = XLColor.Pink; + + a1.Style.Font.FontName = "Arial"; + a2.Style.Font.FontName = "Times New Roman"; + b1.Style.Font.FontName = "Calibri"; + b2.Style.Font.FontName = "Cambria"; + + // Act + ws.Range("A1:B2").Style.Font.FontColor = XLColor.PowderBlue; + + //Assert + Assert.AreEqual(XLColor.Red, ws.Cell("A1").Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Cell("A2").Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Blue, ws.Cell("B1").Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Pink, ws.Cell("B2").Style.Fill.BackgroundColor); + + Assert.AreEqual("Arial", ws.Cell("A1").Style.Font.FontName); + Assert.AreEqual("Times New Roman", ws.Cell("A2").Style.Font.FontName); + Assert.AreEqual("Calibri", ws.Cell("B1").Style.Font.FontName); + Assert.AreEqual("Cambria", ws.Cell("B2").Style.Font.FontName); + + Assert.AreEqual(XLColor.PowderBlue, ws.Cell("A1").Style.Font.FontColor); + Assert.AreEqual(XLColor.PowderBlue, ws.Cell("A2").Style.Font.FontColor); + Assert.AreEqual(XLColor.PowderBlue, ws.Cell("B1").Style.Font.FontColor); + Assert.AreEqual(XLColor.PowderBlue, ws.Cell("B2").Style.Font.FontColor); } [Test] @@ -114,15 +112,13 @@ public void ChangeDetachedStyleProtection() [Test] public void ChangeAttachedStyleAlignment() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var a1 = ws.Cell("A1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var a1 = ws.Cell("A1"); - a1.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Justify; + a1.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Justify; - Assert.AreEqual(XLAlignmentHorizontalValues.Justify, a1.Style.Alignment.Horizontal); - } + Assert.AreEqual(XLAlignmentHorizontalValues.Justify, a1.Style.Alignment.Horizontal); } } } diff --git a/ClosedXML.Tests/Excel/Styles/StyleTests.cs b/ClosedXML.Tests/Excel/Styles/StyleTests.cs index 3f08e8dab..c23f5f592 100644 --- a/ClosedXML.Tests/Excel/Styles/StyleTests.cs +++ b/ClosedXML.Tests/Excel/Styles/StyleTests.cs @@ -5,7 +5,7 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Styles { [TestFixture] public class StyleTests @@ -13,34 +13,32 @@ public class StyleTests [Test] public void EmptyCellWithQuotePrefixNotTreatedAsEmpty() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Empty cell with quote prefix:"); - var cell = ws.FirstCell().CellRight() as XLCell; + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Empty cell with quote prefix:"); + var cell = ws.FirstCell().CellRight() as XLCell; - Assert.IsTrue(cell.IsEmpty()); - cell.Style.IncludeQuotePrefix = true; + Assert.IsTrue(cell.IsEmpty()); + cell.Style.IncludeQuotePrefix = true; - Assert.IsTrue(cell.IsEmpty()); - Assert.IsFalse(cell.IsEmpty(XLCellsUsedOptions.All)); + Assert.IsTrue(cell.IsEmpty()); + Assert.IsFalse(cell.IsEmpty(XLCellsUsedOptions.All)); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var cell = ws.FirstCell().CellRight() as XLCell; - Assert.AreEqual(1, cell.SharedStringId); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var cell = ws.FirstCell().CellRight() as XLCell; + Assert.AreEqual(1, cell.SharedStringId); - Assert.IsTrue(cell.IsEmpty()); - Assert.IsFalse(cell.IsEmpty(XLCellsUsedOptions.All)); - } + Assert.IsTrue(cell.IsEmpty()); + Assert.IsFalse(cell.IsEmpty(XLCellsUsedOptions.All)); } } @@ -51,34 +49,30 @@ public void EmptyCellWithQuotePrefixNotTreatedAsEmpty() [TestCase("F6", TestName = "Non-initialized cell")] public void CellTakesWorksheetStyle(string cellAddress) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Column(2); - ws.Row(2); - ws.Cell("D4").Value = "Non empty"; - ws.Style.Font.SetFontName("Arial"); - ws.Style.Font.SetFontSize(9); - - var cell = ws.Cell(cellAddress); - Assert.AreEqual("Arial", cell.Style.Font.FontName); - Assert.AreEqual(9, cell.Style.Font.FontSize); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Column(2); + ws.Row(2); + ws.Cell("D4").Value = "Non empty"; + ws.Style.Font.SetFontName("Arial"); + ws.Style.Font.SetFontSize(9); + + var cell = ws.Cell(cellAddress); + Assert.AreEqual("Arial", cell.Style.Font.FontName); + Assert.AreEqual(9, cell.Style.Font.FontSize); } [TestCaseSource(nameof(StylizedEntities))] public void WorksheetStyleAffectsAllNestedEntities(Func getEntityStyle) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); - ws.Style.Font.FontSize = 8; + ws.Style.Font.FontSize = 8; - var style = getEntityStyle(ws); + var style = getEntityStyle(ws); - Assert.AreEqual(8, style.Font.FontSize); - } + Assert.AreEqual(8, style.Font.FontSize); } private static IEnumerable StylizedEntities diff --git a/ClosedXML.Tests/Excel/Styles/XLFillTests.cs b/ClosedXML.Tests/Excel/Styles/XLFillTests.cs index cbf7d39fc..492c2423c 100644 --- a/ClosedXML.Tests/Excel/Styles/XLFillTests.cs +++ b/ClosedXML.Tests/Excel/Styles/XLFillTests.cs @@ -2,7 +2,7 @@ using NUnit.Framework; using System.IO; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Styles { [TestFixture] public class XLFillTests @@ -79,7 +79,7 @@ public void SolidFillsWithDifferentPatternColorEqual() [Test] public void BackgroundWithConditionalFormat() { - var workbook = new XLWorkbook(); + using var workbook = new XLWorkbook(); var worksheet = workbook.AddWorksheet("Test"); worksheet.Cell(2, 2).SetValue("Text"); var cf = worksheet.Cell(2, 2).AddConditionalFormat(); @@ -102,16 +102,22 @@ public void BackgroundWithConditionalFormat() [Test] public void LoadAndSaveTransparentBackgroundFill() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\TransparentBackgroundFill\inputfile.xlsx"))) - using (var ms = new MemoryStream()) + var expectedFilePath = @"Other\StyleReferenceFiles\TransparentBackgroundFill\TransparentBackgroundFill.xlsx"; + + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\StyleReferenceFiles\TransparentBackgroundFill\inputfile.xlsx")); + using var ms = new MemoryStream(); + + TestHelper.CreateAndCompare(() => { - TestHelper.CreateAndCompare(() => - { - var wb = new XLWorkbook(stream); - wb.SaveAs(ms); - return wb; - }, @"Other\StyleReferenceFiles\TransparentBackgroundFill\TransparentBackgroundFill.xlsx"); - } + var wb = new XLWorkbook(stream); + + wb.SaveAs(ms); + + //Uncomment to replace expectation running.net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "Resource", expectedFilePath)); + //wb.SaveAs(expectedFileInVsSolution); + return wb; + }, expectedFilePath); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Tables/AddingAndReplacingTableDataTests.cs b/ClosedXML.Tests/Excel/Tables/AddingAndReplacingTableDataTests.cs index c5c94e408..b14c019c5 100644 --- a/ClosedXML.Tests/Excel/Tables/AddingAndReplacingTableDataTests.cs +++ b/ClosedXML.Tests/Excel/Tables/AddingAndReplacingTableDataTests.cs @@ -14,8 +14,8 @@ public class AppendingAndReplacingTableDataTests { public class TestObjectWithoutAttributes { - public String Column1 { get; set; } - public String Column2 { get; set; } + public string Column1 { get; set; } + public string Column2 { get; set; } } public class Person @@ -23,13 +23,13 @@ public class Person public int Age { get; set; } [XLColumn(Header = "Last name", Order = 2)] - public String LastName { get; set; } + public string LastName { get; set; } [XLColumn(Header = "First name", Order = 1)] - public String FirstName { get; set; } + public string FirstName { get; set; } [XLColumn(Header = "Full name", Order = 0)] - public String FullName { get => string.Concat(FirstName, " ", LastName); } + public string FullName => string.Concat(FirstName, " ", LastName); [XLColumn(Order = 3)] public DateTime DateOfBirth { get; set; } @@ -38,9 +38,8 @@ public class Person public bool IsActive; } - private XLWorkbook PrepareWorkbook() + private XLWorkbook PrepareWorkbook(XLWorkbook wb) { - var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Tables"); var data = new[] @@ -57,9 +56,9 @@ private XLWorkbook PrepareWorkbook() return wb; } - private XLWorkbook PrepareWorkbookWithAdditionalColumns() + private XLWorkbook PrepareWorkbookWithAdditionalColumns(XLWorkbook emptyXLWorkbook) { - var wb = PrepareWorkbook(); + var wb = PrepareWorkbook(emptyXLWorkbook); var ws = wb.Worksheets.First(); var table = ws.Tables.First(); @@ -77,599 +76,594 @@ private XLWorkbook PrepareWorkbookWithAdditionalColumns() return wb; } - private Person[] NewData - { - get - { - return new[] + private Person[] NewData => new[] { new Person{FirstName = "Michelle", LastName = "de Beer", Age = 35, DateOfBirth = new DateTime(1983,1,1), IsActive = false}, new Person{FirstName = "Marichen", LastName = "van der Gryp", Age = 30, DateOfBirth = new DateTime(1990,1,1), IsActive = true} }; - } - } [Test] public void AddingEmptyEnumerables() + { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyXLWorkbook = new XLWorkbook(); - var table = ws.Tables.First(); + using var wb = PrepareWorkbook(emptyXLWorkbook); + var ws = wb.Worksheets.First(); + + var table = ws.Tables.First(); - IEnumerable personEnumerable = null; - Assert.AreEqual(null, table.AppendData(personEnumerable)); + IEnumerable personEnumerable = null; + Assert.AreEqual(null, table.AppendData(personEnumerable)); - personEnumerable = new Person[] { }; - Assert.AreEqual(null, table.AppendData(personEnumerable)); + personEnumerable = new Person[] { }; + Assert.AreEqual(null, table.AppendData(personEnumerable)); - IEnumerable enumerable = null; - Assert.AreEqual(null, table.AppendData(enumerable)); + IEnumerable enumerable = null; + Assert.AreEqual(null, table.AppendData(enumerable)); - enumerable = new Person[] { }; - Assert.AreEqual(null, table.AppendData(enumerable)); - } + enumerable = new Person[] { }; + Assert.AreEqual(null, table.AppendData(enumerable)); } [Test] public void ReplaceWithEmptyEnumerables() { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + using var emptyXLWorkbook = new XLWorkbook(); - var table = ws.Tables.First(); + using var wb = PrepareWorkbook(emptyXLWorkbook); + var ws = wb.Worksheets.First(); + + var table = ws.Tables.First(); - IEnumerable personEnumerable = null; - Assert.Throws(() => table.ReplaceData(personEnumerable)); + IEnumerable personEnumerable = null; + Assert.Throws(() => table.ReplaceData(personEnumerable)); - personEnumerable = new Person[] { }; - Assert.Throws(() => table.ReplaceData(personEnumerable)); + personEnumerable = new Person[] { }; + Assert.Throws(() => table.ReplaceData(personEnumerable)); - IEnumerable enumerable = null; - Assert.Throws(() => table.ReplaceData(enumerable)); + IEnumerable enumerable = null; + Assert.Throws(() => table.ReplaceData(enumerable)); - enumerable = new Person[] { }; - Assert.Throws(() => table.ReplaceData(enumerable)); - } + enumerable = new Person[] { }; + Assert.Throws(() => table.ReplaceData(enumerable)); } [Test] public void CanAppendTypedEnumerable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = NewData; - var addedRange = table.AppendData(personEnumerable); + IEnumerable personEnumerable = NewData; + var addedRange = table.AppendData(personEnumerable); - Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(5, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(5, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanAppendToTableWithTotalsRow() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); - table.SetShowTotalsRow(true); - table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; + var table = ws.Tables.First(); + table.SetShowTotalsRow(true); + table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; - IEnumerable personEnumerable = NewData; - var addedRange = table.AppendData(personEnumerable); + IEnumerable personEnumerable = NewData; + var addedRange = table.AppendData(personEnumerable); - Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(5, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(5, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanAppendTypedEnumerableAndPushDownCellsBelowTable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + var value = "Some value that will be overwritten"; + IXLAddress address; + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - var value = "Some value that will be overwritten"; - IXLAddress address; - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - var cell = table.LastRow().FirstCell().CellRight(2).CellBelow(1); - address = cell.Address; - cell.Value = value; + var cell = table.LastRow().FirstCell().CellRight(2).CellBelow(1); + address = cell.Address; + cell.Value = value; - IEnumerable personEnumerable = NewData; - var addedRange = table.AppendData(personEnumerable); + IEnumerable personEnumerable = NewData; + var addedRange = table.AppendData(personEnumerable); - Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - var cell = ws.Cell(address); - Assert.AreEqual("de Beer", cell.Value); - Assert.AreEqual(5, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); + var cell = ws.Cell(address); + Assert.AreEqual("de Beer", cell.Value); + Assert.AreEqual(5, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); - Assert.AreEqual(value, cell.CellBelow(NewData.Count()).Value); - } + Assert.AreEqual(value, cell.CellBelow(NewData.Length).Value); } } [Test] public void CanAppendUntypedEnumerable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - var list = new ArrayList(); - list.AddRange(NewData); + var list = new ArrayList(); + list.AddRange(NewData); - var addedRange = table.AppendData(list); + var addedRange = table.AppendData(list); - Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); + Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(5, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(5, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanAppendDataTable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = NewData; + IEnumerable personEnumerable = NewData; - var ws2 = wb.AddWorksheet("temp"); - var dataTable = ws2.FirstCell().InsertTable(personEnumerable).AsNativeDataTable(); + var ws2 = wb.AddWorksheet("temp"); + var dataTable = ws2.FirstCell().InsertTable(personEnumerable).AsNativeDataTable(); - var addedRange = table.AppendData(dataTable); + var addedRange = table.AppendData(dataTable); - Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B6:G7", addedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(5, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(5, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceWithTypedEnumerable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = NewData; - var replacedRange = table.ReplaceData(personEnumerable); + IEnumerable personEnumerable = NewData; + var replacedRange = table.ReplaceData(personEnumerable); - Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(2, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(2, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceWithUntypedEnumerable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - var list = new ArrayList(); - list.AddRange(NewData); + var list = new ArrayList(); + list.AddRange(NewData); - var replacedRange = table.ReplaceData(list); + var replacedRange = table.ReplaceData(list); - Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); + Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(2, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(2, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceWithDataTable() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = NewData; + IEnumerable personEnumerable = NewData; - var ws2 = wb.AddWorksheet("temp"); - var dataTable = ws2.FirstCell().InsertTable(personEnumerable).AsNativeDataTable(); + var ws2 = wb.AddWorksheet("temp"); + var dataTable = ws2.FirstCell().InsertTable(personEnumerable).AsNativeDataTable(); - var replacedRange = table.ReplaceData(dataTable); + var replacedRange = table.ReplaceData(dataTable); - Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B3:G4", replacedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(2, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(2, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceToTableWithTablesRow1() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); - table.SetShowTotalsRow(true); - table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; + var table = ws.Tables.First(); + table.SetShowTotalsRow(true); + table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; - // Will cause table to overflow - IEnumerable personEnumerable = NewData.Union(NewData).Union(NewData); - var replacedRange = table.ReplaceData(personEnumerable); + // Will cause table to overflow + var personEnumerable = NewData.Union(NewData).Union(NewData); + var replacedRange = table.ReplaceData(personEnumerable); - Assert.AreEqual("B3:G8", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B3:G8", replacedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(6, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(6, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceToTableWithTablesRow2() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbook(emptyXLWorkbook)) { - using (var wb = PrepareWorkbook()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); - table.SetShowTotalsRow(true); - table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; + var table = ws.Tables.First(); + table.SetShowTotalsRow(true); + table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Average; - // Will cause table to shrink - IEnumerable personEnumerable = NewData.Take(1); - var replacedRange = table.ReplaceData(personEnumerable); + // Will cause table to shrink + var personEnumerable = NewData.Take(1); + var replacedRange = table.ReplaceData(personEnumerable); - Assert.AreEqual("B3:G3", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B3:G3", replacedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(1, table.DataRange.RowCount()); - Assert.AreEqual(6, table.DataRange.ColumnCount()); - } + Assert.AreEqual(1, table.DataRange.RowCount()); + Assert.AreEqual(6, table.DataRange.ColumnCount()); } } [Test] public void CanReplaceWithUntypedEnumerableAndPropagateExtraColumns() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbookWithAdditionalColumns(emptyXLWorkbook)) { - using (var wb = PrepareWorkbookWithAdditionalColumns()) - { - var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var ws = wb.Worksheets.First(); + var table = ws.Tables.First(); - var list = new ArrayList(); - list.AddRange(NewData); - list.AddRange(NewData); + var list = new ArrayList(); + list.AddRange(NewData); + list.AddRange(NewData); - var replacedRange = table.ReplaceData(list, propagateExtraColumns: true); + var replacedRange = table.ReplaceData(list, propagateExtraColumns: true); - Assert.AreEqual("B3:G6", replacedRange.RangeAddress.ToString()); + Assert.AreEqual("B3:G6", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(4, table.DataRange.RowCount()); - Assert.AreEqual(10, table.DataRange.ColumnCount()); + Assert.AreEqual(4, table.DataRange.RowCount()); + Assert.AreEqual(10, table.DataRange.ColumnCount()); - Assert.AreEqual("SUM($G$3:G5)", table.Worksheet.Cell("H5").FormulaA1); - Assert.AreEqual("SUM($G$3:G6)", table.Worksheet.Cell("H6").FormulaA1); - Assert.AreEqual(100, table.Worksheet.Cell("H5").Value); - Assert.AreEqual(130, table.Worksheet.Cell("H6").Value); + Assert.AreEqual("SUM($G$3:G5)", table.Worksheet.Cell("H5").FormulaA1); + Assert.AreEqual("SUM($G$3:G6)", table.Worksheet.Cell("H6").FormulaA1); + Assert.AreEqual(100, table.Worksheet.Cell("H5").Value); + Assert.AreEqual(130, table.Worksheet.Cell("H6").Value); - Assert.AreEqual("LEN(B5)", table.Worksheet.Cell("I5").FormulaA1); - Assert.AreEqual("LEN(B6)", table.Worksheet.Cell("I6").FormulaA1); - Assert.AreEqual(16, table.Worksheet.Cell("I5").Value); - Assert.AreEqual(21, table.Worksheet.Cell("I6").Value); + Assert.AreEqual("LEN(B5)", table.Worksheet.Cell("I5").FormulaA1); + Assert.AreEqual("LEN(B6)", table.Worksheet.Cell("I6").FormulaA1); + Assert.AreEqual(16, table.Worksheet.Cell("I5").Value); + Assert.AreEqual(21, table.Worksheet.Cell("I6").Value); - Assert.AreEqual("G5>=40", table.Worksheet.Cell("J5").FormulaA1); - Assert.AreEqual("G6>=40", table.Worksheet.Cell("J6").FormulaA1); - Assert.AreEqual(false, table.Worksheet.Cell("J5").Value); - Assert.AreEqual(false, table.Worksheet.Cell("J6").Value); + Assert.AreEqual("G5>=40", table.Worksheet.Cell("J5").FormulaA1); + Assert.AreEqual("G6>=40", table.Worksheet.Cell("J6").FormulaA1); + Assert.AreEqual(false, table.Worksheet.Cell("J5").Value); + Assert.AreEqual(false, table.Worksheet.Cell("J6").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K5").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K6").Value); - } + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K5").Value); + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K6").Value); } } [Test] public void CanReplaceWithTypedEnumerableAndPropagateExtraColumns() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbookWithAdditionalColumns(emptyXLWorkbook)) { - using (var wb = PrepareWorkbookWithAdditionalColumns()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = NewData.Concat(NewData).OrderBy(p => p.Age); - var replacedRange = table.ReplaceData(personEnumerable, propagateExtraColumns: true); + IEnumerable personEnumerable = NewData.Concat(NewData).OrderBy(p => p.Age); + var replacedRange = table.ReplaceData(personEnumerable, propagateExtraColumns: true); - Assert.AreEqual("B3:G6", replacedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B3:G6", replacedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(4, table.DataRange.RowCount()); - Assert.AreEqual(10, table.DataRange.ColumnCount()); + Assert.AreEqual(4, table.DataRange.RowCount()); + Assert.AreEqual(10, table.DataRange.ColumnCount()); - Assert.AreEqual("SUM($G$3:G5)", table.Worksheet.Cell("H5").FormulaA1); - Assert.AreEqual("SUM($G$3:G6)", table.Worksheet.Cell("H6").FormulaA1); - Assert.AreEqual(95, table.Worksheet.Cell("H5").Value); - Assert.AreEqual(130, table.Worksheet.Cell("H6").Value); + Assert.AreEqual("SUM($G$3:G5)", table.Worksheet.Cell("H5").FormulaA1); + Assert.AreEqual("SUM($G$3:G6)", table.Worksheet.Cell("H6").FormulaA1); + Assert.AreEqual(95, table.Worksheet.Cell("H5").Value); + Assert.AreEqual(130, table.Worksheet.Cell("H6").Value); - Assert.AreEqual("LEN(B5)", table.Worksheet.Cell("I5").FormulaA1); - Assert.AreEqual("LEN(B6)", table.Worksheet.Cell("I6").FormulaA1); - Assert.AreEqual(16, table.Worksheet.Cell("I5").Value); - Assert.AreEqual(16, table.Worksheet.Cell("I6").Value); + Assert.AreEqual("LEN(B5)", table.Worksheet.Cell("I5").FormulaA1); + Assert.AreEqual("LEN(B6)", table.Worksheet.Cell("I6").FormulaA1); + Assert.AreEqual(16, table.Worksheet.Cell("I5").Value); + Assert.AreEqual(16, table.Worksheet.Cell("I6").Value); - Assert.AreEqual("G5>=40", table.Worksheet.Cell("J5").FormulaA1); - Assert.AreEqual("G6>=40", table.Worksheet.Cell("J6").FormulaA1); - Assert.AreEqual(false, table.Worksheet.Cell("J5").Value); - Assert.AreEqual(false, table.Worksheet.Cell("J6").Value); + Assert.AreEqual("G5>=40", table.Worksheet.Cell("J5").FormulaA1); + Assert.AreEqual("G6>=40", table.Worksheet.Cell("J6").FormulaA1); + Assert.AreEqual(false, table.Worksheet.Cell("J5").Value); + Assert.AreEqual(false, table.Worksheet.Cell("J6").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K5").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K6").Value); - } + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K5").Value); + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K6").Value); } } [Test] public void CanAppendWithUntypedEnumerableAndPropagateExtraColumns() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbookWithAdditionalColumns(emptyXLWorkbook)) { - using (var wb = PrepareWorkbookWithAdditionalColumns()) - { - var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var ws = wb.Worksheets.First(); + var table = ws.Tables.First(); - var list = new ArrayList(); - list.AddRange(NewData); - list.AddRange(NewData); + var list = new ArrayList(); + list.AddRange(NewData); + list.AddRange(NewData); - var appendedRange = table.AppendData(list, propagateExtraColumns: true); + var appendedRange = table.AppendData(list, propagateExtraColumns: true); - Assert.AreEqual("B6:G9", appendedRange.RangeAddress.ToString()); + Assert.AreEqual("B6:G9", appendedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(7, table.DataRange.RowCount()); - Assert.AreEqual(10, table.DataRange.ColumnCount()); + Assert.AreEqual(7, table.DataRange.RowCount()); + Assert.AreEqual(10, table.DataRange.ColumnCount()); - Assert.AreEqual("SUM($G$3:G8)", table.Worksheet.Cell("H8").FormulaA1); - Assert.AreEqual("SUM($G$3:G9)", table.Worksheet.Cell("H9").FormulaA1); - Assert.AreEqual(220, table.Worksheet.Cell("H8").Value); - Assert.AreEqual(250, table.Worksheet.Cell("H9").Value); + Assert.AreEqual("SUM($G$3:G8)", table.Worksheet.Cell("H8").FormulaA1); + Assert.AreEqual("SUM($G$3:G9)", table.Worksheet.Cell("H9").FormulaA1); + Assert.AreEqual(220, table.Worksheet.Cell("H8").Value); + Assert.AreEqual(250, table.Worksheet.Cell("H9").Value); - Assert.AreEqual("LEN(B8)", table.Worksheet.Cell("I8").FormulaA1); - Assert.AreEqual("LEN(B9)", table.Worksheet.Cell("I9").FormulaA1); - Assert.AreEqual(16, table.Worksheet.Cell("I8").Value); - Assert.AreEqual(21, table.Worksheet.Cell("I9").Value); + Assert.AreEqual("LEN(B8)", table.Worksheet.Cell("I8").FormulaA1); + Assert.AreEqual("LEN(B9)", table.Worksheet.Cell("I9").FormulaA1); + Assert.AreEqual(16, table.Worksheet.Cell("I8").Value); + Assert.AreEqual(21, table.Worksheet.Cell("I9").Value); - Assert.AreEqual("G8>=40", table.Worksheet.Cell("J8").FormulaA1); - Assert.AreEqual("G9>=40", table.Worksheet.Cell("J9").FormulaA1); - Assert.AreEqual(false, table.Worksheet.Cell("J8").Value); - Assert.AreEqual(false, table.Worksheet.Cell("J9").Value); + Assert.AreEqual("G8>=40", table.Worksheet.Cell("J8").FormulaA1); + Assert.AreEqual("G9>=40", table.Worksheet.Cell("J9").FormulaA1); + Assert.AreEqual(false, table.Worksheet.Cell("J8").Value); + Assert.AreEqual(false, table.Worksheet.Cell("J9").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K8").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K9").Value); - } + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K8").Value); + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K9").Value); } } [Test] public void CanAppendTypedEnumerableAndPropagateExtraColumns() { - using (var ms = new MemoryStream()) + using var emptyXLWorkbook = new XLWorkbook(); + + using var ms = new MemoryStream(); + using (var wb = PrepareWorkbookWithAdditionalColumns(emptyXLWorkbook)) { - using (var wb = PrepareWorkbookWithAdditionalColumns()) - { - var ws = wb.Worksheets.First(); + var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + var table = ws.Tables.First(); - IEnumerable personEnumerable = - NewData - .Concat(NewData) - .Concat(NewData) - .OrderBy(p => p.FirstName); + IEnumerable personEnumerable = + NewData + .Concat(NewData) + .Concat(NewData) + .OrderBy(p => p.FirstName); - var addedRange = table.AppendData(personEnumerable); + var addedRange = table.AppendData(personEnumerable); - Assert.AreEqual("B6:G11", addedRange.RangeAddress.ToString()); - ws.Columns().AdjustToContents(); + Assert.AreEqual("B6:G11", addedRange.RangeAddress.ToString()); + ws.Columns().AdjustToContents(); - wb.SaveAs(ms); - } + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); + using (var wb = new XLWorkbook(ms)) + { + var table = wb.Worksheets.SelectMany(ws => ws.Tables).First(); - Assert.AreEqual(9, table.DataRange.RowCount()); - Assert.AreEqual(10, table.DataRange.ColumnCount()); + Assert.AreEqual(9, table.DataRange.RowCount()); + Assert.AreEqual(10, table.DataRange.ColumnCount()); - Assert.AreEqual("SUM($G$3:G10)", table.Worksheet.Cell("H10").FormulaA1); - Assert.AreEqual("SUM($G$3:G11)", table.Worksheet.Cell("H11").FormulaA1); - Assert.AreEqual(280, table.Worksheet.Cell("H10").Value); - Assert.AreEqual(315, table.Worksheet.Cell("H11").Value); + Assert.AreEqual("SUM($G$3:G10)", table.Worksheet.Cell("H10").FormulaA1); + Assert.AreEqual("SUM($G$3:G11)", table.Worksheet.Cell("H11").FormulaA1); + Assert.AreEqual(280, table.Worksheet.Cell("H10").Value); + Assert.AreEqual(315, table.Worksheet.Cell("H11").Value); - Assert.AreEqual("LEN(B10)", table.Worksheet.Cell("I10").FormulaA1); - Assert.AreEqual("LEN(B11)", table.Worksheet.Cell("I11").FormulaA1); - Assert.AreEqual(16, table.Worksheet.Cell("I10").Value); - Assert.AreEqual(16, table.Worksheet.Cell("I11").Value); + Assert.AreEqual("LEN(B10)", table.Worksheet.Cell("I10").FormulaA1); + Assert.AreEqual("LEN(B11)", table.Worksheet.Cell("I11").FormulaA1); + Assert.AreEqual(16, table.Worksheet.Cell("I10").Value); + Assert.AreEqual(16, table.Worksheet.Cell("I11").Value); - Assert.AreEqual("G10>=40", table.Worksheet.Cell("J10").FormulaA1); - Assert.AreEqual("G11>=40", table.Worksheet.Cell("J11").FormulaA1); - Assert.AreEqual(false, table.Worksheet.Cell("J10").Value); - Assert.AreEqual(false, table.Worksheet.Cell("J11").Value); + Assert.AreEqual("G10>=40", table.Worksheet.Cell("J10").FormulaA1); + Assert.AreEqual("G11>=40", table.Worksheet.Cell("J11").FormulaA1); + Assert.AreEqual(false, table.Worksheet.Cell("J10").Value); + Assert.AreEqual(false, table.Worksheet.Cell("J11").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K10").Value); - Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K11").Value); - } + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K10").Value); + Assert.AreEqual("40 is not old!", table.Worksheet.Cell("K11").Value); } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Tables/TablesTests.cs b/ClosedXML.Tests/Excel/Tables/TablesTests.cs index 1fc6963f7..bfa976ad7 100644 --- a/ClosedXML.Tests/Excel/Tables/TablesTests.cs +++ b/ClosedXML.Tests/Excel/Tables/TablesTests.cs @@ -1,6 +1,7 @@ using ClosedXML.Attributes; using ClosedXML.Excel; using ClosedXML.Excel.Exceptions; +using ClosedXML.Excel.Tables; using NUnit.Framework; using System; using System.Collections.Generic; @@ -8,15 +9,15 @@ using System.IO; using System.Linq; -namespace ClosedXML.Tests.Excel +namespace ClosedXML.Tests.Excel.Tables { [TestFixture] public class TablesTests { public class TestObjectWithoutAttributes { - public String Column1 { get; set; } - public String Column2 { get; set; } + public string Column1 { get; set; } + public string Column2 { get; set; } } public class TestObjectWithAttributes @@ -24,10 +25,10 @@ public class TestObjectWithAttributes public int UnOrderedColumn { get; set; } [XLColumn(Header = "SecondColumn", Order = 1)] - public String Column1 { get; set; } + public string Column1 { get; set; } [XLColumn(Header = "FirstColumn", Order = 0)] - public String Column2 { get; set; } + public string Column2 { get; set; } [XLColumn(Header = "SomeFieldNotProperty", Order = 2)] public int MyField; @@ -36,178 +37,154 @@ public class TestObjectWithAttributes [Test] public void CanSaveTableCreatedFromEmptyDataTable() { - var dt = new DataTable("sheet1"); + using var dt = new DataTable("sheet1"); dt.Columns.Add("col1", typeof(string)); dt.Columns.Add("col2", typeof(double)); - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet(dt); + using var wb = new XLWorkbook(); + wb.AddWorksheet(dt); - using (var ms = new MemoryStream()) - wb.SaveAs(ms, true); - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } [Test] public void PreventAddingOfEmptyDataTable() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var dt = new DataTable(); - var table = ws.FirstCell().InsertTable(dt); + using var dt = new DataTable(); + var table = ws.FirstCell().InsertTable(dt); - Assert.AreEqual(null, table); - } + Assert.AreEqual(null, table); } [Test] public void CanSaveTableCreatedFromSingleRow() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Title"); - ws.Range("A1").CreateTable(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Title"); + ws.Range("A1").CreateTable(); - using (var ms = new MemoryStream()) - wb.SaveAs(ms, true); - } + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); } [Test] public void CreatingATableFromHeadersPushCellsBelow() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Title") - .CellBelow().SetValue("X"); - ws.Range("A1").CreateTable(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Title") + .CellBelow().SetValue("X"); + ws.Range("A1").CreateTable(); - Assert.AreEqual(String.Empty, ws.Cell("A2").GetString()); - Assert.AreEqual("X", ws.Cell("A3").GetString()); - } + Assert.AreEqual(string.Empty, ws.Cell("A2").GetString()); + Assert.AreEqual("X", ws.Cell("A3").GetString()); } [Test] public void Inserting_Column_Sets_Header() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Categories") - .CellBelow().SetValue("A") - .CellBelow().SetValue("B") - .CellBelow().SetValue("C"); - - IXLTable table = ws.RangeUsed().CreateTable(); - table.InsertColumnsAfter(1); - Assert.AreEqual("Column2", table.HeadersRow().LastCell().GetString()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Categories") + .CellBelow().SetValue("A") + .CellBelow().SetValue("B") + .CellBelow().SetValue("C"); + + var table = ws.RangeUsed().CreateTable(); + table.InsertColumnsAfter(1); + Assert.AreEqual("Column2", table.HeadersRow().LastCell().GetString()); } [Test] public void DataRange_returns_null_if_empty() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Categories") - .CellBelow().SetValue("A") - .CellBelow().SetValue("B") - .CellBelow().SetValue("C"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Categories") + .CellBelow().SetValue("A") + .CellBelow().SetValue("B") + .CellBelow().SetValue("C"); - IXLTable table = ws.RangeUsed().CreateTable(); + var table = ws.RangeUsed().CreateTable(); - ws.Rows("2:4").Delete(); + ws.Rows("2:4").Delete(); - Assert.IsNull(table.DataRange); - } + Assert.IsNull(table.DataRange); } [Test] public void SavingLoadingTableWithNewLineInHeader() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - string columnName = "Line1" + Environment.NewLine + "Line2"; - ws.FirstCell().SetValue(columnName) - .CellBelow().SetValue("A"); - ws.RangeUsed().CreateTable(); - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - var wb2 = new XLWorkbook(ms); - IXLWorksheet ws2 = wb2.Worksheet(1); - IXLTable table2 = ws2.Table(0); - string fieldName = table2.Field(0).Name; - Assert.AreEqual("Line1\nLine2", fieldName); - } - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var columnName = "Line1" + XLConstants.NewLine + "Line2"; + ws.FirstCell().SetValue(columnName) + .CellBelow().SetValue("A"); + ws.RangeUsed().CreateTable(); + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); + using var wb2 = new XLWorkbook(ms); + var ws2 = wb2.Worksheet(1); + var table2 = ws2.Table(0); + var fieldName = table2.Field(0).Name; + Assert.AreEqual("Line1\nLine2", fieldName); } [Test] public void SavingLoadingTableWithNewLineInHeader2() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.Worksheets.Add("Test"); - - var dt = new DataTable(); - string columnName = "Line1" + Environment.NewLine + "Line2"; - dt.Columns.Add(columnName); - - DataRow dr = dt.NewRow(); - dr[columnName] = "some text"; - dt.Rows.Add(dr); - ws.Cell(1, 1).InsertTable(dt); - - IXLTable table1 = ws.Table(0); - string fieldName1 = table1.Field(0).Name; - Assert.AreEqual(columnName, fieldName1); - - using (var ms = new MemoryStream()) - { - wb.SaveAs(ms, true); - var wb2 = new XLWorkbook(ms); - IXLWorksheet ws2 = wb2.Worksheet(1); - IXLTable table2 = ws2.Table(0); - string fieldName2 = table2.Field(0).Name; - Assert.AreEqual("Line1\nLine2", fieldName2); - } - } + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Test"); + + using var dt = new DataTable(); + var columnName = "Line1" + XLConstants.NewLine + "Line2"; + dt.Columns.Add(columnName); + + var dr = dt.NewRow(); + dr[columnName] = "some text"; + dt.Rows.Add(dr); + ws.Cell(1, 1).InsertTable(dt); + + var table1 = ws.Table(0); + var fieldName1 = table1.Field(0).Name; + Assert.AreEqual(columnName, fieldName1); + + using var ms = new MemoryStream(); + wb.SaveAs(ms, true); + using var wb2 = new XLWorkbook(ms); + var ws2 = wb2.Worksheet(1); + var table2 = ws2.Table(0); + var fieldName2 = table2.Field(0).Name; + Assert.AreEqual("Line1\nLine2", fieldName2); } [Test] public void TableCreatedFromEmptyDataTable() { - var dt = new DataTable("sheet1"); + using var dt = new DataTable("sheet1"); dt.Columns.Add("col1", typeof(string)); dt.Columns.Add("col2", typeof(double)); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(dt); - Assert.AreEqual(2, ws.Tables.First().ColumnCount()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(dt); + Assert.AreEqual(2, ws.Tables.First().ColumnCount()); } [Test] public void TableCreatedFromEmptyListOfInt() { - var l = new List(); + var l = new List(); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - Assert.AreEqual(1, ws.Tables.First().ColumnCount()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + Assert.AreEqual(1, ws.Tables.First().ColumnCount()); } [Test] @@ -215,12 +192,10 @@ public void TableCreatedFromEmptyListOfObject() { var l = new List(); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - Assert.AreEqual(2, ws.Tables.First().ColumnCount()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + Assert.AreEqual(2, ws.Tables.First().ColumnCount()); } [Test] @@ -232,16 +207,14 @@ public void TableCreatedFromListOfObjectWithPropertyAttributes() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - Assert.AreEqual(4, ws.Tables.First().ColumnCount()); - Assert.AreEqual("FirstColumn", ws.FirstCell().Value); - Assert.AreEqual("SecondColumn", ws.FirstCell().CellRight().Value); - Assert.AreEqual("SomeFieldNotProperty", ws.FirstCell().CellRight().CellRight().Value); - Assert.AreEqual("UnOrderedColumn", ws.FirstCell().CellRight().CellRight().CellRight().Value); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + Assert.AreEqual(4, ws.Tables.First().ColumnCount()); + Assert.AreEqual("FirstColumn", ws.FirstCell().Value); + Assert.AreEqual("SecondColumn", ws.FirstCell().CellRight().Value); + Assert.AreEqual("SomeFieldNotProperty", ws.FirstCell().CellRight().CellRight().Value); + Assert.AreEqual("UnOrderedColumn", ws.FirstCell().CellRight().CellRight().CellRight().Value); } [Test] @@ -249,203 +222,189 @@ public void EmptyTableCreatedFromListOfObjectWithPropertyAttributes() { var l = new List(); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - Assert.AreEqual(4, ws.Tables.First().ColumnCount()); - Assert.AreEqual("FirstColumn", ws.FirstCell().Value); - Assert.AreEqual("SecondColumn", ws.FirstCell().CellRight().Value); - Assert.AreEqual("SomeFieldNotProperty", ws.FirstCell().CellRight().CellRight().Value); - Assert.AreEqual("UnOrderedColumn", ws.FirstCell().CellRight().CellRight().CellRight().Value); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + Assert.AreEqual(4, ws.Tables.First().ColumnCount()); + Assert.AreEqual("FirstColumn", ws.FirstCell().Value); + Assert.AreEqual("SecondColumn", ws.FirstCell().CellRight().Value); + Assert.AreEqual("SomeFieldNotProperty", ws.FirstCell().CellRight().CellRight().Value); + Assert.AreEqual("UnOrderedColumn", ws.FirstCell().CellRight().CellRight().CellRight().Value); } [Test] public void TableInsertAboveFromData() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Value"); - - IXLTable table = ws.Range("A1:A2").CreateTable(); - table.SetShowTotalsRow() - .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; - - IXLTableRow row = table.DataRange.FirstRow(); - row.Field("Value").Value = 3; - row = table.DataRange.InsertRowsAbove(1).First(); - row.Field("Value").Value = 2; - row = table.DataRange.InsertRowsAbove(1).First(); - row.Field("Value").Value = 1; - - Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); - Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); - Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Value"); + + var table = ws.Range("A1:A2").CreateTable(); + table.SetShowTotalsRow() + .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; + + var row = table.DataRange.FirstRow(); + row.Field("Value").Value = 3; + row = table.DataRange.InsertRowsAbove(1).First(); + row.Field("Value").Value = 2; + row = table.DataRange.InsertRowsAbove(1).First(); + row.Field("Value").Value = 1; + + Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); + Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); + Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); } [Test] public void TableInsertAboveFromRows() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Value"); - - IXLTable table = ws.Range("A1:A2").CreateTable(); - table.SetShowTotalsRow() - .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; - - IXLTableRow row = table.DataRange.FirstRow(); - row.Field("Value").Value = 3; - row = row.InsertRowsAbove(1).First(); - row.Field("Value").Value = 2; - row = row.InsertRowsAbove(1).First(); - row.Field("Value").Value = 1; - - Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); - Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); - Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Value"); + + var table = ws.Range("A1:A2").CreateTable(); + table.SetShowTotalsRow() + .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; + + var row = table.DataRange.FirstRow(); + row.Field("Value").Value = 3; + row = row.InsertRowsAbove(1).First(); + row.Field("Value").Value = 2; + row = row.InsertRowsAbove(1).First(); + row.Field("Value").Value = 1; + + Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); + Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); + Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); } [Test] public void TableInsertBelowFromData() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Value"); - - IXLTable table = ws.Range("A1:A2").CreateTable(); - table.SetShowTotalsRow() - .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; - - IXLTableRow row = table.DataRange.FirstRow(); - row.Field("Value").Value = 1; - row = table.DataRange.InsertRowsBelow(1).First(); - row.Field("Value").Value = 2; - row = table.DataRange.InsertRowsBelow(1).First(); - row.Field("Value").Value = 3; - - Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); - Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); - Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Value"); + + var table = ws.Range("A1:A2").CreateTable(); + table.SetShowTotalsRow() + .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; + + var row = table.DataRange.FirstRow(); + row.Field("Value").Value = 1; + row = table.DataRange.InsertRowsBelow(1).First(); + row.Field("Value").Value = 2; + row = table.DataRange.InsertRowsBelow(1).First(); + row.Field("Value").Value = 3; + + Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); + Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); + Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); } [Test] public void TableInsertBelowFromRows() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Value"); - - IXLTable table = ws.Range("A1:A2").CreateTable(); - table.SetShowTotalsRow() - .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; - - IXLTableRow row = table.DataRange.FirstRow(); - row.Field("Value").Value = 1; - row = row.InsertRowsBelow(1).First(); - row.Field("Value").Value = 2; - row = row.InsertRowsBelow(1).First(); - row.Field("Value").Value = 3; - - Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); - Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); - Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Value"); + + var table = ws.Range("A1:A2").CreateTable(); + table.SetShowTotalsRow() + .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum; + + var row = table.DataRange.FirstRow(); + row.Field("Value").Value = 1; + row = row.InsertRowsBelow(1).First(); + row.Field("Value").Value = 2; + row = row.InsertRowsBelow(1).First(); + row.Field("Value").Value = 3; + + Assert.AreEqual(1, ws.Cell(2, 1).GetDouble()); + Assert.AreEqual(2, ws.Cell(3, 1).GetDouble()); + Assert.AreEqual(3, ws.Cell(4, 1).GetDouble()); } [Test] public void TableShowHeader() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Categories") - .CellBelow().SetValue("A") - .CellBelow().SetValue("B") - .CellBelow().SetValue("C"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Categories") + .CellBelow().SetValue("A") + .CellBelow().SetValue("B") + .CellBelow().SetValue("C"); - IXLTable table = ws.RangeUsed().CreateTable(); + var table = ws.RangeUsed().CreateTable(); - Assert.AreEqual("Categories", table.Fields.First().Name); + Assert.AreEqual("Categories", table.Fields.First().Name); - table.SetShowHeaderRow(false); + table.SetShowHeaderRow(false); - Assert.AreEqual("Categories", table.Fields.First().Name); + Assert.AreEqual("Categories", table.Fields.First().Name); - Assert.IsTrue(ws.Cell(1, 1).IsEmpty(XLCellsUsedOptions.All)); - Assert.AreEqual(null, table.HeadersRow()); - Assert.AreEqual("A", table.DataRange.FirstRow().Field("Categories").GetString()); - Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString()); - Assert.AreEqual("A", table.DataRange.FirstCell().GetString()); - Assert.AreEqual("C", table.DataRange.LastCell().GetString()); + Assert.IsTrue(ws.Cell(1, 1).IsEmpty(XLCellsUsedOptions.All)); + Assert.AreEqual(null, table.HeadersRow()); + Assert.AreEqual("A", table.DataRange.FirstRow().Field("Categories").GetString()); + Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString()); + Assert.AreEqual("A", table.DataRange.FirstCell().GetString()); + Assert.AreEqual("C", table.DataRange.LastCell().GetString()); - table.SetShowHeaderRow(); - IXLRangeRow headerRow = table.HeadersRow(); - Assert.AreNotEqual(null, headerRow); - Assert.AreEqual("Categories", headerRow.Cell(1).GetString()); + table.SetShowHeaderRow(); + var headerRow = table.HeadersRow(); + Assert.AreNotEqual(null, headerRow); + Assert.AreEqual("Categories", headerRow.Cell(1).GetString()); - table.SetShowHeaderRow(false); + table.SetShowHeaderRow(false); - ws.FirstCell().SetValue("x"); + ws.FirstCell().SetValue("x"); - table.SetShowHeaderRow(); + table.SetShowHeaderRow(); - Assert.AreEqual("x", ws.FirstCell().GetString()); - Assert.AreEqual("Categories", ws.Cell("A2").GetString()); - Assert.AreNotEqual(null, headerRow); - Assert.AreEqual("A", table.DataRange.FirstRow().Field("Categories").GetString()); - Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString()); - Assert.AreEqual("A", table.DataRange.FirstCell().GetString()); - Assert.AreEqual("C", table.DataRange.LastCell().GetString()); - } + Assert.AreEqual("x", ws.FirstCell().GetString()); + Assert.AreEqual("Categories", ws.Cell("A2").GetString()); + Assert.AreNotEqual(null, headerRow); + Assert.AreEqual("A", table.DataRange.FirstRow().Field("Categories").GetString()); + Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString()); + Assert.AreEqual("A", table.DataRange.FirstCell().GetString()); + Assert.AreEqual("C", table.DataRange.LastCell().GetString()); } [Test] public void ChangeFieldName() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet"); - ws.Cell("A1").SetValue("FName") - .CellBelow().SetValue("John"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet"); + ws.Cell("A1").SetValue("FName") + .CellBelow().SetValue("John"); - ws.Cell("B1").SetValue("LName") - .CellBelow().SetValue("Doe"); + ws.Cell("B1").SetValue("LName") + .CellBelow().SetValue("Doe"); - var tbl = ws.RangeUsed().CreateTable(); - var nameBefore = tbl.Field(tbl.Fields.Last().Index).Name; - tbl.Field(tbl.Fields.Last().Index).Name = "LastName"; - var nameAfter = tbl.Field(tbl.Fields.Last().Index).Name; + var tbl = ws.RangeUsed().CreateTable(); + var nameBefore = tbl.Field(tbl.Fields.Last().Index).Name; + tbl.Field(tbl.Fields.Last().Index).Name = "LastName"; + var nameAfter = tbl.Field(tbl.Fields.Last().Index).Name; - var cellValue = ws.Cell("B1").GetString(); + var cellValue = ws.Cell("B1").GetString(); - Assert.AreEqual("LName", nameBefore); - Assert.AreEqual("LastName", nameAfter); - Assert.AreEqual("LastName", cellValue); + Assert.AreEqual("LName", nameBefore); + Assert.AreEqual("LastName", nameAfter); + Assert.AreEqual("LastName", cellValue); - tbl.ShowHeaderRow = false; - tbl.Field(tbl.Fields.Last().Index).Name = "LastNameChanged"; - nameAfter = tbl.Field(tbl.Fields.Last().Index).Name; - Assert.AreEqual("LastNameChanged", nameAfter); + tbl.ShowHeaderRow = false; + tbl.Field(tbl.Fields.Last().Index).Name = "LastNameChanged"; + nameAfter = tbl.Field(tbl.Fields.Last().Index).Name; + Assert.AreEqual("LastNameChanged", nameAfter); - tbl.SetShowHeaderRow(true); - nameAfter = tbl.Cell("B1").Value.ToString(); - Assert.AreEqual("LastNameChanged", nameAfter); + tbl.SetShowHeaderRow(true); + nameAfter = tbl.Cell("B1").Value.ToString(); + Assert.AreEqual("LastNameChanged", nameAfter); - var field = tbl.Field("LastNameChanged"); - Assert.AreEqual("LastNameChanged", field.Name); + var field = tbl.Field("LastNameChanged"); + Assert.AreEqual("LastNameChanged", field.Name); - tbl.Cell(1, 1).Value = "FirstName"; - Assert.AreEqual("FirstName", tbl.Field(0).Name); - } + tbl.Cell(1, 1).Value = "FirstName"; + Assert.AreEqual("FirstName", tbl.Field(0).Name); } [Test] @@ -457,21 +416,19 @@ public void CanDeleteTableColumn() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var table = ws.FirstCell().InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.FirstCell().InsertTable(l); - table.Column("C").Delete(); + table.Column("C").Delete(); - Assert.AreEqual(3, table.Fields.Count()); + Assert.AreEqual(3, table.Fields.Count()); - Assert.AreEqual("FirstColumn", table.Fields.First().Name); - Assert.AreEqual(0, table.Fields.First().Index); + Assert.AreEqual("FirstColumn", table.Fields.First().Name); + Assert.AreEqual(0, table.Fields.First().Index); - Assert.AreEqual("UnOrderedColumn", table.Fields.Last().Name); - Assert.AreEqual(2, table.Fields.Last().Index); - } + Assert.AreEqual("UnOrderedColumn", table.Fields.Last().Name); + Assert.AreEqual(2, table.Fields.Last().Index); } [Test] @@ -483,36 +440,34 @@ public void TestFieldCellTypes() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var table = ws.Cell("B2").InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.Cell("B2").InsertTable(l); - Assert.AreEqual(4, table.Fields.Count()); + Assert.AreEqual(4, table.Fields.Count()); - Assert.AreEqual("B2", table.Field(0).HeaderCell.Address.ToString()); - Assert.AreEqual("C2", table.Field(1).HeaderCell.Address.ToString()); - Assert.AreEqual("D2", table.Field(2).HeaderCell.Address.ToString()); - Assert.AreEqual("E2", table.Field(3).HeaderCell.Address.ToString()); + Assert.AreEqual("B2", table.Field(0).HeaderCell.Address.ToString()); + Assert.AreEqual("C2", table.Field(1).HeaderCell.Address.ToString()); + Assert.AreEqual("D2", table.Field(2).HeaderCell.Address.ToString()); + Assert.AreEqual("E2", table.Field(3).HeaderCell.Address.ToString()); - Assert.IsNull(table.Field(0).TotalsCell); - Assert.IsNull(table.Field(1).TotalsCell); - Assert.IsNull(table.Field(2).TotalsCell); - Assert.IsNull(table.Field(3).TotalsCell); + Assert.IsNull(table.Field(0).TotalsCell); + Assert.IsNull(table.Field(1).TotalsCell); + Assert.IsNull(table.Field(2).TotalsCell); + Assert.IsNull(table.Field(3).TotalsCell); - table.SetShowTotalsRow(); + table.SetShowTotalsRow(); - Assert.AreEqual("B5", table.Field(0).TotalsCell.Address.ToString()); - Assert.AreEqual("C5", table.Field(1).TotalsCell.Address.ToString()); - Assert.AreEqual("D5", table.Field(2).TotalsCell.Address.ToString()); - Assert.AreEqual("E5", table.Field(3).TotalsCell.Address.ToString()); + Assert.AreEqual("B5", table.Field(0).TotalsCell.Address.ToString()); + Assert.AreEqual("C5", table.Field(1).TotalsCell.Address.ToString()); + Assert.AreEqual("D5", table.Field(2).TotalsCell.Address.ToString()); + Assert.AreEqual("E5", table.Field(3).TotalsCell.Address.ToString()); - var field = table.Fields.Last(); + var field = table.Fields.Last(); - Assert.AreEqual("E2:E5", field.Column.RangeAddress.ToString()); - Assert.AreEqual("E3", field.DataCells.First().Address.ToString()); - Assert.AreEqual("E4", field.DataCells.Last().Address.ToString()); - } + Assert.AreEqual("E2:E5", field.Column.RangeAddress.ToString()); + Assert.AreEqual("E3", field.DataCells.First().Address.ToString()); + Assert.AreEqual("E4", field.DataCells.Last().Address.ToString()); } [Test] @@ -524,46 +479,42 @@ public void CanDeleteTable() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - wb.SaveAs(ms); - } + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + wb.SaveAs(ms); + } - ms.Seek(0, SeekOrigin.Begin); + ms.Seek(0, SeekOrigin.Begin); - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.First(); - var table = ws.Tables.First(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.First(); + var table = ws.Tables.First(); - ws.Tables.Remove(table.Name); - Assert.AreEqual(0, ws.Tables.Count()); - wb.Save(); - } + ws.Tables.Remove(table.Name); + Assert.AreEqual(0, ws.Tables.Count()); + wb.Save(); } } [Test] public void TableNameCannotBeValidCellName() { - var dt = new DataTable("sheet1"); + using var dt = new DataTable("sheet1"); dt.Columns.Add("Patient", typeof(string)); dt.Rows.Add("David"); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "May2019")); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "A1")); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "R1C2")); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "r3c2")); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "R2C33333")); - Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "RC")); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "May2019")); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "A1")); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "R1C2")); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "r3c2")); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "R2C33333")); + Assert.Throws(() => ws.Cell(1, 1).InsertTable(dt, "RC")); } [Test] @@ -575,25 +526,23 @@ public void CanDeleteTableField() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var table = ws.Cell("B2").InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.Cell("B2").InsertTable(l); - Assert.AreEqual("B2:E4", table.RangeAddress.ToString()); + Assert.AreEqual("B2:E4", table.RangeAddress.ToString()); - table.Field("SomeFieldNotProperty").Delete(); + table.Field("SomeFieldNotProperty").Delete(); - Assert.AreEqual(3, table.Fields.Count()); + Assert.AreEqual(3, table.Fields.Count()); - Assert.AreEqual("FirstColumn", table.Fields.First().Name); - Assert.AreEqual(0, table.Fields.First().Index); + Assert.AreEqual("FirstColumn", table.Fields.First().Name); + Assert.AreEqual(0, table.Fields.First().Index); - Assert.AreEqual("UnOrderedColumn", table.Fields.Last().Name); - Assert.AreEqual(2, table.Fields.Last().Index); + Assert.AreEqual("UnOrderedColumn", table.Fields.Last().Name); + Assert.AreEqual(2, table.Fields.Last().Index); - Assert.AreEqual("B2:D4", table.RangeAddress.ToString()); - } + Assert.AreEqual("B2:D4", table.RangeAddress.ToString()); } [Test] @@ -607,78 +556,72 @@ public void CanDeleteTableRows() new TestObjectWithAttributes() { Column1 = "g", Column2 = "h", MyField = 7, UnOrderedColumn = 333 } }; - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var table = ws.Cell("B2").InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.Cell("B2").InsertTable(l); - Assert.AreEqual("B2:E6", table.RangeAddress.ToString()); + Assert.AreEqual("B2:E6", table.RangeAddress.ToString()); - table.DataRange.Rows(3, 4).Delete(); + table.DataRange.Rows(3, 4).Delete(); - Assert.AreEqual(2, table.DataRange.Rows().Count()); + Assert.AreEqual(2, table.DataRange.Rows().Count()); - Assert.AreEqual("b", table.DataRange.FirstCell().Value); - Assert.AreEqual(777, table.DataRange.LastCell().Value); + Assert.AreEqual("b", table.DataRange.FirstCell().Value); + Assert.AreEqual(777, table.DataRange.LastCell().Value); - Assert.AreEqual("B2:E4", table.RangeAddress.ToString()); - } + Assert.AreEqual("B2:E4", table.RangeAddress.ToString()); } [Test] public void OverlappingTablesThrowsException() { - var dt = new DataTable("sheet1"); + using var dt = new DataTable("sheet1"); dt.Columns.Add("col1", typeof(string)); dt.Columns.Add("col2", typeof(double)); - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(dt, true); - Assert.Throws(() => ws.FirstCell().CellRight().InsertTable(dt, true)); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(dt, true); + Assert.Throws(() => ws.FirstCell().CellRight().InsertTable(dt, true)); } [Test] public void OverwritingTableTotalsRow() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var data1 = Enumerable.Range(1, 10) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('a', i) - }); - - var table = ws.FirstCell().InsertTable(data1, true) - .SetShowHeaderRow() - .SetShowTotalsRow(); - table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; - - var data2 = Enumerable.Range(1, 20) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('b', i), - Int = 64 + i - }); - - ws.FirstCell().CellBelow().InsertData(data2); - - table.Fields.ForEach(f => Assert.AreEqual(XLTotalsRowFunction.None, f.TotalsRowFunction)); - - Assert.AreEqual("11", table.Field(0).TotalsRowLabel); - Assert.AreEqual("K", table.Field(1).TotalsRowLabel); - Assert.AreEqual("bbbbbbbbbbb", table.Field(2).TotalsRowLabel); - } + var data1 = Enumerable.Range(1, 10) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('a', i) + }); + + var table = ws.FirstCell().InsertTable(data1, true) + .SetShowHeaderRow() + .SetShowTotalsRow(); + table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; + + var data2 = Enumerable.Range(1, 20) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('b', i), + Int = 64 + i + }); + + ws.FirstCell().CellBelow().InsertData(data2); + + table.Fields.ForEach(f => Assert.AreEqual(XLTotalsRowFunction.None, f.TotalsRowFunction)); + + Assert.AreEqual("11", table.Field(0).TotalsRowLabel); + Assert.AreEqual("K", table.Field(1).TotalsRowLabel); + Assert.AreEqual("bbbbbbbbbbb", table.Field(2).TotalsRowLabel); } [Test] @@ -690,79 +633,75 @@ public void TableRenameTests() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - var table1 = ws.FirstCell().InsertTable(l); - var table2 = ws.Cell("A10").InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table1 = ws.FirstCell().InsertTable(l); + var table2 = ws.Cell("A10").InsertTable(l); - Assert.AreEqual("Table1", table1.Name); - Assert.AreEqual("Table2", table2.Name); + Assert.AreEqual("Table1", table1.Name); + Assert.AreEqual("Table2", table2.Name); - table1.Name = "table1"; - Assert.AreEqual("table1", table1.Name); + table1.Name = "table1"; + Assert.AreEqual("table1", table1.Name); - table1.Name = "_table1"; - Assert.AreEqual("_table1", table1.Name); + table1.Name = "_table1"; + Assert.AreEqual("_table1", table1.Name); - table1.Name = "\\table1"; - Assert.AreEqual("\\table1", table1.Name); + table1.Name = "\\table1"; + Assert.AreEqual("\\table1", table1.Name); - Assert.Throws(() => table1.Name = ""); - Assert.Throws(() => table1.Name = "R"); - Assert.Throws(() => table1.Name = "C"); - Assert.Throws(() => table1.Name = "r"); - Assert.Throws(() => table1.Name = "c"); + Assert.Throws(() => table1.Name = ""); + Assert.Throws(() => table1.Name = "R"); + Assert.Throws(() => table1.Name = "C"); + Assert.Throws(() => table1.Name = "r"); + Assert.Throws(() => table1.Name = "c"); - Assert.Throws(() => table1.Name = "123"); - Assert.Throws(() => table1.Name = new String('A', 256)); + Assert.Throws(() => table1.Name = "123"); + Assert.Throws(() => table1.Name = new string('A', 256)); - Assert.Throws(() => table1.Name = "Table2"); - Assert.Throws(() => table1.Name = "TABLE2"); - } + Assert.Throws(() => table1.Name = "Table2"); + Assert.Throws(() => table1.Name = "TABLE2"); } [Test] public void CanResizeTable() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var data1 = Enumerable.Range(1, 10) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('a', i) - }); - - var table = ws.FirstCell().InsertTable(data1, true) - .SetShowHeaderRow() - .SetShowTotalsRow(); - table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; - - var data2 = Enumerable.Range(1, 10) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('b', i), - Integer = 64 + i - }); - - ws.FirstCell().CellBelow().InsertData(data2); - table.Resize(table.FirstCell().Address, table.AsRange().LastCell().CellRight().Address); - - Assert.AreEqual(4, table.Fields.Count()); - - Assert.AreEqual("Column4", table.Field(3).Name); - - ws.Cell("D1").Value = "Integer"; - Assert.AreEqual("Integer", table.Field(3).Name); - } + var data1 = Enumerable.Range(1, 10) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('a', i) + }); + + var table = ws.FirstCell().InsertTable(data1, true) + .SetShowHeaderRow() + .SetShowTotalsRow(); + table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; + + var data2 = Enumerable.Range(1, 10) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('b', i), + Integer = 64 + i + }); + + ws.FirstCell().CellBelow().InsertData(data2); + table.Resize(table.FirstCell().Address, table.AsRange().LastCell().CellRight().Address); + + Assert.AreEqual(4, table.Fields.Count()); + + Assert.AreEqual("Column4", table.Field(3).Name); + + ws.Cell("D1").Value = "Integer"; + Assert.AreEqual("Integer", table.Field(3).Name); } [Test] @@ -774,22 +713,20 @@ public void TableAsDynamicEnumerable() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - var table = ws.FirstCell().InsertTable(l); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.FirstCell().InsertTable(l); - foreach (var d in table.AsDynamicEnumerable()) + foreach (var d in table.AsDynamicEnumerable()) + { + Assert.DoesNotThrow(() => { - Assert.DoesNotThrow(() => - { - object value; - value = d.FirstColumn; - value = d.SecondColumn; - value = d.UnOrderedColumn; - value = d.SomeFieldNotProperty; - }); - } + object value; + value = d.FirstColumn; + value = d.SecondColumn; + value = d.UnOrderedColumn; + value = d.SomeFieldNotProperty; + }); } } @@ -802,62 +739,58 @@ public void TableAsDotNetDataTable() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - var table = ws.FirstCell().InsertTable(l).AsNativeDataTable(); - - Assert.AreEqual(4, table.Columns.Count); - Assert.AreEqual("FirstColumn", table.Columns[0].ColumnName); - Assert.AreEqual("SecondColumn", table.Columns[1].ColumnName); - Assert.AreEqual("SomeFieldNotProperty", table.Columns[2].ColumnName); - Assert.AreEqual("UnOrderedColumn", table.Columns[3].ColumnName); - - Assert.AreEqual(typeof(String), table.Columns[0].DataType); - Assert.AreEqual(typeof(String), table.Columns[1].DataType); - Assert.AreEqual(typeof(Double), table.Columns[2].DataType); - Assert.AreEqual(typeof(Double), table.Columns[3].DataType); - - var dr = table.Rows[0]; - Assert.AreEqual("b", dr["FirstColumn"]); - Assert.AreEqual("a", dr["SecondColumn"]); - Assert.AreEqual(4, dr["SomeFieldNotProperty"]); - Assert.AreEqual(999, dr["UnOrderedColumn"]); - - dr = table.Rows[1]; - Assert.AreEqual("d", dr["FirstColumn"]); - Assert.AreEqual("c", dr["SecondColumn"]); - Assert.AreEqual(5, dr["SomeFieldNotProperty"]); - Assert.AreEqual(777, dr["UnOrderedColumn"]); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var table = ws.FirstCell().InsertTable(l).AsNativeDataTable(); + + Assert.AreEqual(4, table.Columns.Count); + Assert.AreEqual("FirstColumn", table.Columns[0].ColumnName); + Assert.AreEqual("SecondColumn", table.Columns[1].ColumnName); + Assert.AreEqual("SomeFieldNotProperty", table.Columns[2].ColumnName); + Assert.AreEqual("UnOrderedColumn", table.Columns[3].ColumnName); + + Assert.AreEqual(typeof(string), table.Columns[0].DataType); + Assert.AreEqual(typeof(string), table.Columns[1].DataType); + Assert.AreEqual(typeof(double), table.Columns[2].DataType); + Assert.AreEqual(typeof(double), table.Columns[3].DataType); + + var dr = table.Rows[0]; + Assert.AreEqual("b", dr["FirstColumn"]); + Assert.AreEqual("a", dr["SecondColumn"]); + Assert.AreEqual(4, dr["SomeFieldNotProperty"]); + Assert.AreEqual(999, dr["UnOrderedColumn"]); + + dr = table.Rows[1]; + Assert.AreEqual("d", dr["FirstColumn"]); + Assert.AreEqual("c", dr["SecondColumn"]); + Assert.AreEqual(5, dr["SomeFieldNotProperty"]); + Assert.AreEqual(777, dr["UnOrderedColumn"]); } [Test] public void TestTableCellTypes() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var data1 = Enumerable.Range(1, 10) - .Select(i => - new - { - Index = i, - Character = Convert.ToChar(64 + i), - String = new String('a', i) - }); - - var table = ws.FirstCell().InsertTable(data1, true) - .SetShowHeaderRow() - .SetShowTotalsRow(); - table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; - - Assert.AreEqual(XLTableCellType.Header, table.HeadersRow().Cell(1).TableCellType()); - Assert.AreEqual(XLTableCellType.Data, table.HeadersRow().Cell(1).CellBelow().TableCellType()); - Assert.AreEqual(XLTableCellType.Total, table.TotalsRow().Cell(1).TableCellType()); - Assert.AreEqual(XLTableCellType.None, ws.Cell("Z100").TableCellType()); - } + var data1 = Enumerable.Range(1, 10) + .Select(i => + new + { + Index = i, + Character = Convert.ToChar(64 + i), + String = new string('a', i) + }); + + var table = ws.FirstCell().InsertTable(data1, true) + .SetShowHeaderRow() + .SetShowTotalsRow(); + table.Fields.First().TotalsRowFunction = XLTotalsRowFunction.Sum; + + Assert.AreEqual(XLTableCellType.Header, table.HeadersRow().Cell(1).TableCellType()); + Assert.AreEqual(XLTableCellType.Data, table.HeadersRow().Cell(1).CellBelow().TableCellType()); + Assert.AreEqual(XLTableCellType.Total, table.TotalsRow().Cell(1).TableCellType()); + Assert.AreEqual(XLTableCellType.None, ws.Cell("Z100").TableCellType()); } [Test] @@ -869,31 +802,29 @@ public void TotalsFunctionsOfHeadersWithWeirdCharacters() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l, false); - - // Give the headings weird names (i.e. spaces, hashes, single quotes - ws.Cell("A1").Value = "ABCD "; - ws.Cell("B1").Value = " #BCD"; - ws.Cell("C1").Value = " as'df "; - ws.Cell("D1").Value = "Normal"; - - var table = ws.RangeUsed().CreateTable(); - Assert.IsNotNull(table); - - table.ShowTotalsRow = true; - table.Field(0).TotalsRowFunction = XLTotalsRowFunction.Count; - table.Field(1).TotalsRowFunction = XLTotalsRowFunction.Count; - table.Field(2).TotalsRowFunction = XLTotalsRowFunction.Sum; - table.Field(3).TotalsRowFunction = XLTotalsRowFunction.Sum; - - Assert.AreEqual("SUBTOTAL(103,Table1[[ABCD ]])", table.Field(0).TotalsRowFormulaA1); - Assert.AreEqual("SUBTOTAL(103,Table1[[ '#BCD]])", table.Field(1).TotalsRowFormulaA1); - Assert.AreEqual("SUBTOTAL(109,Table1[[ as''df ]])", table.Field(2).TotalsRowFormulaA1); - Assert.AreEqual("SUBTOTAL(109,[Normal])", table.Field(3).TotalsRowFormulaA1); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l, false); + + // Give the headings weird names (i.e. spaces, hashes, single quotes + ws.Cell("A1").Value = "ABCD "; + ws.Cell("B1").Value = " #BCD"; + ws.Cell("C1").Value = " as'df "; + ws.Cell("D1").Value = "Normal"; + + var table = ws.RangeUsed().CreateTable(); + Assert.IsNotNull(table); + + table.ShowTotalsRow = true; + table.Field(0).TotalsRowFunction = XLTotalsRowFunction.Count; + table.Field(1).TotalsRowFunction = XLTotalsRowFunction.Count; + table.Field(2).TotalsRowFunction = XLTotalsRowFunction.Sum; + table.Field(3).TotalsRowFunction = XLTotalsRowFunction.Sum; + + Assert.AreEqual("SUBTOTAL(103,Table1[[ABCD ]])", table.Field(0).TotalsRowFormulaA1); + Assert.AreEqual("SUBTOTAL(103,Table1[[ '#BCD]])", table.Field(1).TotalsRowFormulaA1); + Assert.AreEqual("SUBTOTAL(109,Table1[[ as''df ]])", table.Field(2).TotalsRowFormulaA1); + Assert.AreEqual("SUBTOTAL(109,[Normal])", table.Field(3).TotalsRowFormulaA1); } [Test] @@ -905,12 +836,10 @@ public void CannotCreateDuplicateTablesOverSameRange() new TestObjectWithAttributes() { Column1 = "c", Column2 = "d", MyField = 5, UnOrderedColumn = 777 } }; - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().InsertTable(l); - Assert.Throws(() => ws.RangeUsed().CreateTable()); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().InsertTable(l); + Assert.Throws(() => ws.RangeUsed().CreateTable()); } [Test] @@ -934,12 +863,12 @@ public void CannotCreateTableOverExistingAutoFilter() [Test] public void CopyTableSameWorksheet() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); var table = ws1.Range("A1:C2").AsTable(); - TestDelegate action = () => table.CopyTo(ws1); + void action() => table.CopyTo(ws1); Assert.Throws(typeof(InvalidOperationException), action); } @@ -947,7 +876,7 @@ public void CopyTableSameWorksheet() [Test] public void CopyDetachedTableDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); ws1.Cell("A1").Value = "Custom column 1"; ws1.Cell("B1").Value = "Custom column 2"; @@ -977,7 +906,7 @@ public void CopyDetachedTableDifferentWorksheets() [Test] public void CopyTableDifferentWorksheets() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); ws1.Cell("A1").Value = "Custom column 1"; ws1.Cell("B1").Value = "Custom column 2"; @@ -1010,54 +939,52 @@ public void CopyTableDifferentWorksheets() [Test] public void NewTableHasNullRelId() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell("A1").Value = "Custom column 1"; - ws.Cell("B1").Value = "Custom column 2"; - ws.Cell("C1").Value = "Custom column 3"; - ws.Cell("A2").Value = "Value 1"; - ws.Cell("B2").Value = 123.45; - ws.Cell("C2").Value = new DateTime(2018, 5, 10); - var original = ws.Range("A1:C2").CreateTable("Attached table"); - - Assert.AreEqual(1, ws.Tables.Count()); - Assert.IsNull((original as XLTable).RelId); - - wb.SaveAs(ms); - } + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell("A1").Value = "Custom column 1"; + ws.Cell("B1").Value = "Custom column 2"; + ws.Cell("C1").Value = "Custom column 3"; + ws.Cell("A2").Value = "Value 1"; + ws.Cell("B2").Value = 123.45; + ws.Cell("C2").Value = new DateTime(2018, 5, 10); + var original = ws.Range("A1:C2").CreateTable("Attached table"); + + Assert.AreEqual(1, ws.Tables.Count()); + Assert.IsNull((original as XLTable).RelId); + + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws = wb.Worksheets.Add("Sheet2"); - var original = wb.Worksheets.First().Tables.First(); + using (var wb = new XLWorkbook(ms)) + { + var ws = wb.Worksheets.Add("Sheet2"); + var original = wb.Worksheets.First().Tables.First(); - Assert.IsNotNull((original as XLTable).RelId); + Assert.IsNotNull((original as XLTable).RelId); - var copy = original.CopyTo(ws); + var copy = original.CopyTo(ws); - Assert.AreEqual(1, ws.Tables.Count()); - Assert.IsNull((copy as XLTable).RelId); + Assert.AreEqual(1, ws.Tables.Count()); + Assert.IsNull((copy as XLTable).RelId); - AssertTablesAreEqual(original, copy); + AssertTablesAreEqual(original, copy); - Assert.AreEqual("Sheet2!A1:C2", copy.RangeAddress.ToString(XLReferenceStyle.A1, true)); - Assert.AreEqual("Custom column 1", ws.Cell("A1").Value); - Assert.AreEqual("Custom column 2", ws.Cell("B1").Value); - Assert.AreEqual("Custom column 3", ws.Cell("C1").Value); - Assert.AreEqual("Value 1", ws.Cell("A2").Value); - Assert.AreEqual(123.45, (double)ws.Cell("B2").Value, XLHelper.Epsilon); - Assert.AreEqual(new DateTime(2018, 5, 10), ws.Cell("C2").Value); - } + Assert.AreEqual("Sheet2!A1:C2", copy.RangeAddress.ToString(XLReferenceStyle.A1, true)); + Assert.AreEqual("Custom column 1", ws.Cell("A1").Value); + Assert.AreEqual("Custom column 2", ws.Cell("B1").Value); + Assert.AreEqual("Custom column 3", ws.Cell("C1").Value); + Assert.AreEqual("Value 1", ws.Cell("A2").Value); + Assert.AreEqual(123.45, (double)ws.Cell("B2").Value, XLHelper.Epsilon); + Assert.AreEqual(new DateTime(2018, 5, 10), ws.Cell("C2").Value); } } [Test] public void CopyTableWithoutData() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add("Sheet1"); ws1.Cell("A1").Value = "Custom column 1"; ws1.Cell("B1").Value = "Custom column 2"; @@ -1085,87 +1012,79 @@ public void CopyTableWithoutData() [Test] public void SavingTableWithNullDataRangeThrowsException() { - using (var ms = new MemoryStream()) - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var ms = new MemoryStream(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - var data = Enumerable.Range(1, 10) - .Select(i => new - { - Number = i, - NumberString = String.Concat("Number", i.ToString()) - }); + var data = Enumerable.Range(1, 10) + .Select(i => new + { + Number = i, + NumberString = string.Concat("Number", i.ToString()) + }); - var table = ws.FirstCell() - .InsertTable(data) - .SetShowTotalsRow(); + var table = ws.FirstCell() + .InsertTable(data) + .SetShowTotalsRow(); - table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Count; + table.Fields.Last().TotalsRowFunction = XLTotalsRowFunction.Count; - table.DataRange.Rows() - .OrderByDescending(r => r.RowNumber()) - .ToList() - .ForEach(r => r.WorksheetRow().Delete()); + table.DataRange.Rows() + .OrderByDescending(r => r.RowNumber()) + .ToList() + .ForEach(r => r.WorksheetRow().Delete()); - Assert.IsNull(table.DataRange); - Assert.Throws(() => wb.SaveAs(ms)); - } + Assert.IsNull(table.DataRange); + Assert.Throws(() => wb.SaveAs(ms)); } [Test] public void CanCreateTableWithWhiteSpaceColumnHeaders() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").SetValue("Header"); - ws.Cell("B1").SetValue(new string(' ', 1)); - ws.Cell("C1").SetValue(new string(' ', 2)); - ws.Cell("D1").SetValue(new string(' ', 3)); + ws.Cell("A1").SetValue("Header"); + ws.Cell("B1").SetValue(new string(' ', 1)); + ws.Cell("C1").SetValue(new string(' ', 2)); + ws.Cell("D1").SetValue(new string(' ', 3)); - var table = ws.Range("A1:E3").CreateTable("Table1"); + var table = ws.Range("A1:E3").CreateTable("Table1"); - Assert.AreEqual("Header", table.Field(0).Name); - Assert.AreEqual(new string(' ', 1), table.Field(1).Name); - Assert.AreEqual(new string(' ', 2), table.Field(2).Name); - Assert.AreEqual(new string(' ', 3), table.Field(3).Name); - Assert.AreEqual("Column5", table.Field(4).Name); - } + Assert.AreEqual("Header", table.Field(0).Name); + Assert.AreEqual(new string(' ', 1), table.Field(1).Name); + Assert.AreEqual(new string(' ', 2), table.Field(2).Name); + Assert.AreEqual(new string(' ', 3), table.Field(3).Name); + Assert.AreEqual("Column5", table.Field(4).Name); } [Test] public void TableNotFound() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - Assert.Throws(() => ws.Table("dummy")); - Assert.Throws(() => wb.Table("dummy")); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.Throws(() => ws.Table("dummy")); + Assert.Throws(() => wb.Table("dummy")); } [Test] public void SecondTableOnNewSheetHasUniqueName() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet(); - var t1 = ws1.FirstCell().InsertTable(Enumerable.Range(1, 10).Select(i => new { Number = i })); - Assert.AreEqual("Table1", t1.Name); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet(); + var t1 = ws1.FirstCell().InsertTable(Enumerable.Range(1, 10).Select(i => new { Number = i })); + Assert.AreEqual("Table1", t1.Name); - var ws2 = wb.AddWorksheet(); - var t2 = ws2.FirstCell().InsertTable(Enumerable.Range(1, 10).Select(i => new { Number = i })); - Assert.AreEqual("Table2", t2.Name); - } + var ws2 = wb.AddWorksheet(); + var t2 = ws2.FirstCell().InsertTable(Enumerable.Range(1, 10).Select(i => new { Number = i })); + Assert.AreEqual("Table2", t2.Name); } private void AssertTablesAreEqual(IXLTable table1, IXLTable table2) { Assert.AreEqual(table1.RangeAddress.ToString(XLReferenceStyle.A1, false), table2.RangeAddress.ToString(XLReferenceStyle.A1, false)); Assert.AreEqual(table1.Fields.Count(), table2.Fields.Count()); - for (int j = 0; j < table1.Fields.Count(); j++) + for (var j = 0; j < table1.Fields.Count(); j++) { var originalField = table1.Fields.ElementAt(j); var copyField = table2.Fields.ElementAt(j); @@ -1189,4 +1108,4 @@ private void AssertTablesAreEqual(IXLTable table1, IXLTable table2) //TODO: Delete table (not underlying range) } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Excel/Worksheets/XLWorksheetTests.cs b/ClosedXML.Tests/Excel/Worksheets/XLWorksheetTests.cs index 07888500b..edd04cc7b 100644 --- a/ClosedXML.Tests/Excel/Worksheets/XLWorksheetTests.cs +++ b/ClosedXML.Tests/Excel/Worksheets/XLWorksheetTests.cs @@ -1,45 +1,46 @@ using ClosedXML.Excel; using ClosedXML.Excel.Drawings; +using ClosedXML.Tests.Utils; using NUnit.Framework; +using SkiaSharp; using System; -using System.Drawing; using System.IO; using System.Linq; using System.Reflection; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Excel.Worksheets { [TestFixture] public class XLWorksheetTests { - private readonly static char[] illegalWorksheetCharacters = "\u0000\u0003:\\/?*[]".ToCharArray(); + private static readonly char[] illegalWorksheetCharacters = "\u0000\u0003:\\/?*[]".ToCharArray(); [Test] public void ColumnCountTime() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - DateTime start = DateTime.Now; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var start = DateTime.Now; ws.ColumnCount(); - DateTime end = DateTime.Now; + var end = DateTime.Now; Assert.IsTrue((end - start).TotalMilliseconds < 500); } [Test] public void CopyConditionalFormatsCount() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); ws.Range("A1:C3").AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue); ws.Range("A1:C3").Value = 1; - IXLWorksheet ws2 = ws.CopyTo("Sheet2"); + var ws2 = ws.CopyTo("Sheet2"); Assert.AreEqual(1, ws2.ConditionalFormats.Count()); } [Test] public void CopyColumnVisibility() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet1"); ws.Columns(10, 20).Hide(); ws.CopyTo("Sheet2"); @@ -49,7 +50,7 @@ public void CopyColumnVisibility() [Test] public void CopyRowVisibility() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws = wb.AddWorksheet("Sheet1"); ws.Rows(2, 5).Hide(); ws.CopyTo("Sheet2"); @@ -59,7 +60,7 @@ public void CopyRowVisibility() [Test] public void DeletingSheets1() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.Worksheets.Add("Sheet3"); wb.Worksheets.Add("Sheet2"); wb.Worksheets.Add("Sheet1", 1); @@ -74,7 +75,7 @@ public void DeletingSheets1() [Test] public void InsertingSheets1() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.Worksheets.Add("Sheet1"); wb.Worksheets.Add("Sheet2"); wb.Worksheets.Add("Sheet3"); @@ -87,7 +88,7 @@ public void InsertingSheets1() [Test] public void InsertingSheets2() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.Worksheets.Add("Sheet2"); wb.Worksheets.Add("Sheet1", 1); wb.Worksheets.Add("Sheet3"); @@ -100,7 +101,7 @@ public void InsertingSheets2() [Test] public void InsertingSheets3() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); wb.Worksheets.Add("Sheet3"); wb.Worksheets.Add("Sheet2", 1); wb.Worksheets.Add("Sheet1", 1); @@ -113,7 +114,7 @@ public void InsertingSheets3() [Test] public void InsertingSheets4() { - var wb = new XLWorkbook(); + using var wb = new XLWorkbook(); var ws1 = wb.Worksheets.Add(); Assert.AreEqual("Sheet1", ws1.Name); @@ -135,22 +136,20 @@ public void InsertingSheets4() [Test] public void AddingDuplicateSheetNameThrowsException() { - using (var wb = new XLWorkbook()) - { - IXLWorksheet ws; - ws = wb.AddWorksheet("Sheet1"); + using var wb = new XLWorkbook(); + IXLWorksheet ws; + ws = wb.AddWorksheet("Sheet1"); - Assert.Throws(() => wb.AddWorksheet("Sheet1")); + Assert.Throws(() => wb.AddWorksheet("Sheet1")); - //Sheet names are case insensitive - Assert.Throws(() => wb.AddWorksheet("sheet1")); - } + //Sheet names are case insensitive + Assert.Throws(() => wb.AddWorksheet("sheet1")); } [Test] public void MergedRanges() { - IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1"); + using var xLWorkbook = new XLWorkbook(); var ws = xLWorkbook.Worksheets.Add("Sheet1"); ws.Range("A1:B2").Merge(); ws.Range("C1:D3").Merge(); ws.Range("D2:E2").Merge(); @@ -168,111 +167,104 @@ public void MergedRanges() [Test] public void RowCountTime() { - var wb = new XLWorkbook(); - IXLWorksheet ws = wb.Worksheets.Add("Sheet1"); - DateTime start = DateTime.Now; + using var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var start = DateTime.Now; ws.RowCount(); - DateTime end = DateTime.Now; + var end = DateTime.Now; Assert.IsTrue((end - start).TotalMilliseconds < 500); } [Test] public void SheetsWithCommas() { - using (var wb = new XLWorkbook()) - { - var sourceSheetName = "Sheet1, Sheet3"; - var ws = wb.Worksheets.Add(sourceSheetName); - ws.Cell("A1").Value = 1; - ws.Cell("A2").Value = 2; - ws.Cell("B2").Value = 3; - - ws = wb.Worksheets.Add("Formula"); - ws.FirstCell().FormulaA1 = string.Format("=SUM('{0}'!A1:A2,'{0}'!B1:B2)", sourceSheetName); - - var value = ws.FirstCell().Value; - Assert.AreEqual(6, value); - } + using var wb = new XLWorkbook(); + var sourceSheetName = "Sheet1, Sheet3"; + var ws = wb.Worksheets.Add(sourceSheetName); + ws.Cell("A1").Value = 1; + ws.Cell("A2").Value = 2; + ws.Cell("B2").Value = 3; + + ws = wb.Worksheets.Add("Formula"); + ws.FirstCell().FormulaA1 = string.Format("=SUM('{0}'!A1:A2,'{0}'!B1:B2)", sourceSheetName); + + var value = ws.FirstCell().Value; + Assert.AreEqual(6, value); } [Test] public void CanRenameWorksheet() { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet("Sheet1"); - var ws2 = wb.AddWorksheet("Sheet2"); + using var wb = new XLWorkbook(); + var ws1 = wb.AddWorksheet("Sheet1"); + var ws2 = wb.AddWorksheet("Sheet2"); - ws1.Name = "New sheet name"; - Assert.AreEqual("New sheet name", ws1.Name); + ws1.Name = "New sheet name"; + Assert.AreEqual("New sheet name", ws1.Name); - ws2.Name = "sheet2"; - Assert.AreEqual("sheet2", ws2.Name); + ws2.Name = "sheet2"; + Assert.AreEqual("sheet2", ws2.Name); - Assert.Throws(() => ws1.Name = "SHEET2"); - } + Assert.Throws(() => ws1.Name = "SHEET2"); } [Test] public void TryGetWorksheet() { - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet("Sheet1"); - wb.AddWorksheet("Sheet2"); - - IXLWorksheet ws; - Assert.IsTrue(wb.Worksheets.TryGetWorksheet("Sheet1", out ws)); - Assert.IsTrue(wb.Worksheets.TryGetWorksheet("sheet1", out ws)); - Assert.IsTrue(wb.Worksheets.TryGetWorksheet("sHEeT1", out ws)); - Assert.IsFalse(wb.Worksheets.TryGetWorksheet("Sheeeet2", out ws)); - - Assert.IsTrue(wb.TryGetWorksheet("Sheet1", out ws)); - Assert.IsTrue(wb.TryGetWorksheet("sheet1", out ws)); - Assert.IsTrue(wb.TryGetWorksheet("sHEeT1", out ws)); - Assert.IsFalse(wb.TryGetWorksheet("Sheeeet2", out ws)); - } + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); + wb.AddWorksheet("Sheet2"); + + IXLWorksheet ws; + Assert.IsTrue(wb.Worksheets.TryGetWorksheet("Sheet1", out ws)); + Assert.IsTrue(wb.Worksheets.TryGetWorksheet("sheet1", out ws)); + Assert.IsTrue(wb.Worksheets.TryGetWorksheet("sHEeT1", out ws)); + Assert.IsFalse(wb.Worksheets.TryGetWorksheet("Sheeeet2", out ws)); + + Assert.IsTrue(wb.TryGetWorksheet("Sheet1", out ws)); + Assert.IsTrue(wb.TryGetWorksheet("sheet1", out ws)); + Assert.IsTrue(wb.TryGetWorksheet("sHEeT1", out ws)); + Assert.IsFalse(wb.TryGetWorksheet("Sheeeet2", out ws)); } [Test] public void HideWorksheet() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add("VisibleSheet"); - wb.Worksheets.Add("HiddenSheet").Hide(); - wb.SaveAs(ms); - } + wb.Worksheets.Add("VisibleSheet"); + wb.Worksheets.Add("HiddenSheet").Hide(); + wb.SaveAs(ms); + } - // unhide the hidden sheet - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("VisibleSheet").Visibility); - Assert.AreEqual(XLWorksheetVisibility.Hidden, wb.Worksheet("HiddenSheet").Visibility); + // unhide the hidden sheet + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("VisibleSheet").Visibility); + Assert.AreEqual(XLWorksheetVisibility.Hidden, wb.Worksheet("HiddenSheet").Visibility); - var ws = wb.Worksheet("HiddenSheet"); - ws.Unhide().Name = "NoAlsoVisible"; + var ws = wb.Worksheet("HiddenSheet"); + ws.Unhide().Name = "NoAlsoVisible"; - Assert.AreEqual(XLWorksheetVisibility.Visible, ws.Visibility); + Assert.AreEqual(XLWorksheetVisibility.Visible, ws.Visibility); - wb.Save(); - } + wb.Save(); + } - using (var wb = new XLWorkbook(ms)) - { - Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("VisibleSheet").Visibility); - Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("NoAlsoVisible").Visibility); - } + using (var wb = new XLWorkbook(ms)) + { + Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("VisibleSheet").Visibility); + Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheet("NoAlsoVisible").Visibility); } } [Test] public void CanCopySheetsWithAllAnchorTypes() { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx"))) - using (var wb = new XLWorkbook(stream)) + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\ImageHandling\ImageAnchors.xlsx")); + var wb = new XLWorkbook(stream); + try { var ws = wb.Worksheets.First(); ws.CopyTo("Copy1"); @@ -286,32 +278,32 @@ public void CanCopySheetsWithAllAnchorTypes() var ws4 = wb.Worksheets.Skip(3).First(); ws3.CopyTo("Copy4"); } + finally + { + wb.Dispose(); + } } [Test] public void CannotCopyDeletedWorksheet() { - using (var wb = new XLWorkbook()) - { - wb.AddWorksheet("Sheet1"); - var ws = wb.AddWorksheet("Sheet2"); + using var wb = new XLWorkbook(); + wb.AddWorksheet("Sheet1"); + var ws = wb.AddWorksheet("Sheet2"); - ws.Delete(); - Assert.Throws(() => ws.CopyTo("Copy of Sheet2")); - } + ws.Delete(); + Assert.Throws(() => ws.CopyTo("Copy of Sheet2")); } [Test] public void WorksheetNameCannotStartWithApostrophe() { var title = "'StartsWithApostrophe"; - TestDelegate addWorksheet = () => + void addWorksheet() { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add(title); - } - }; + using var wb = new XLWorkbook(); + wb.Worksheets.Add(title); + } Assert.Throws(typeof(ArgumentException), addWorksheet); } @@ -320,13 +312,11 @@ public void WorksheetNameCannotStartWithApostrophe() public void WorksheetNameCannotEndWithApostrophe() { var title = "EndsWithApostrophe'"; - TestDelegate addWorksheet = () => + void addWorksheet() { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add(title); - } - }; + using var wb = new XLWorkbook(); + wb.Worksheets.Add(title); + } Assert.Throws(typeof(ArgumentException), addWorksheet); } @@ -349,23 +339,21 @@ public void WorksheetNameCanContainApostrophe() { var title = "With'Apostrophe"; var savedTitle = ""; - TestDelegate saveAndOpenWorkbook = () => + void saveAndOpenWorkbook() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - wb.Worksheets.Add(title); - wb.Worksheets.First().Cell(1, 1).FormulaA1 = $"{title}!A2"; - wb.SaveAs(ms); - } - - using (var wb = new XLWorkbook(ms)) - { - savedTitle = wb.Worksheets.First().Name; - } + wb.Worksheets.Add(title); + wb.Worksheets.First().Cell(1, 1).FormulaA1 = $"{title}!A2"; + wb.SaveAs(ms); } - }; + + using (var wb = new XLWorkbook(ms)) + { + savedTitle = wb.Worksheets.First().Name; + } + } Assert.DoesNotThrow(saveAndOpenWorkbook); Assert.AreEqual(title, savedTitle); @@ -374,161 +362,143 @@ public void WorksheetNameCanContainApostrophe() [Test] public void CopyWorksheetPreservesContents() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Cell("A1").Value = "A1 value"; - ws1.Cell("A2").Value = 100; - ws1.Cell("D4").Value = new DateTime(2018, 5, 1); + ws1.Cell("A1").Value = "A1 value"; + ws1.Cell("A2").Value = 100; + ws1.Cell("D4").Value = new DateTime(2018, 5, 1); - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual("A1 value", ws2.Cell("A1").Value); - Assert.AreEqual(100, ws2.Cell("A2").Value); - Assert.AreEqual(new DateTime(2018, 5, 1), ws2.Cell("D4").Value); - } + Assert.AreEqual("A1 value", ws2.Cell("A1").Value); + Assert.AreEqual(100, ws2.Cell("A2").Value); + Assert.AreEqual(new DateTime(2018, 5, 1), ws2.Cell("D4").Value); } [Test] public void CopyWorksheetPreservesFormulae() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Cell("A1").FormulaA1 = "10*10"; - ws1.Cell("A2").FormulaA1 = "A1 * 2"; + ws1.Cell("A1").FormulaA1 = "10*10"; + ws1.Cell("A2").FormulaA1 = "A1 * 2"; - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual("10*10", ws2.Cell("A1").FormulaA1); - Assert.AreEqual("A1 * 2", ws2.Cell("A2").FormulaA1); - } + Assert.AreEqual("10*10", ws2.Cell("A1").FormulaA1); + Assert.AreEqual("A1 * 2", ws2.Cell("A2").FormulaA1); } [Test] public void CopyWorksheetPreservesRowHeights() { - using (var wb1 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); - using (var wb2 = new XLWorkbook()) - { - ws1.RowHeight = 55; - ws1.Row(2).Height = 0; - ws1.Row(3).Height = 20; + using var wb1 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + using var wb2 = new XLWorkbook(); + ws1.RowHeight = 55; + ws1.Row(2).Height = 0; + ws1.Row(3).Height = 20; - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.RowHeight, ws2.RowHeight); - for (int i = 1; i <= 3; i++) - { - Assert.AreEqual(ws1.Row(i).Height, ws2.Row(i).Height); - } - } + Assert.AreEqual(ws1.RowHeight, ws2.RowHeight); + for (var i = 1; i <= 3; i++) + { + Assert.AreEqual(ws1.Row(i).Height, ws2.Row(i).Height); } } [Test] public void CopyWorksheetPreservesColumnWidths() { - using (var wb1 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); - using (var wb2 = new XLWorkbook()) - { - ws1.ColumnWidth = 160; - ws1.Column(2).Width = 0; - ws1.Column(3).Width = 240; + using var wb1 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + using var wb2 = new XLWorkbook(); + ws1.ColumnWidth = 160; + ws1.Column(2).Width = 0; + ws1.Column(3).Width = 240; - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.ColumnWidth, ws2.ColumnWidth); - for (int i = 1; i <= 3; i++) - { - Assert.AreEqual(ws1.Column(i).Width, ws2.Column(i).Width); - } - } + Assert.AreEqual(ws1.ColumnWidth, ws2.ColumnWidth); + for (var i = 1; i <= 3; i++) + { + Assert.AreEqual(ws1.Column(i).Width, ws2.Column(i).Width); } } [Test] public void CopyWorksheetPreservesMergedCells() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Range("A:A").Merge(); - ws1.Range("B1:C2").Merge(); + ws1.Range("A:A").Merge(); + ws1.Range("B1:C2").Merge(); - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.MergedRanges.Count, ws2.MergedRanges.Count); - for (int i = 0; i < ws1.MergedRanges.Count; i++) - { - Assert.AreEqual(ws1.MergedRanges.ElementAt(i).RangeAddress.ToString(), - ws2.MergedRanges.ElementAt(i).RangeAddress.ToString()); - } + Assert.AreEqual(ws1.MergedRanges.Count, ws2.MergedRanges.Count); + for (var i = 0; i < ws1.MergedRanges.Count; i++) + { + Assert.AreEqual(ws1.MergedRanges.ElementAt(i).RangeAddress.ToString(), + ws2.MergedRanges.ElementAt(i).RangeAddress.ToString()); } } [Test] public void CopyWorksheetAcrossWorkbooksPreservesNamedRanges() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Range("A1:A2").AddToNamed("GLOBAL", XLScope.Workbook); - ws1.Ranges("B1:B2,D1:D2").AddToNamed("LOCAL", XLScope.Worksheet); + ws1.Range("A1:A2").AddToNamed("GLOBAL", XLScope.Workbook); + ws1.Ranges("B1:B2,D1:D2").AddToNamed("LOCAL", XLScope.Worksheet); - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.NamedRanges.Count(), ws2.NamedRanges.Count()); - for (int i = 0; i < ws1.NamedRanges.Count(); i++) - { - var nr1 = ws1.NamedRanges.ElementAt(i); - var nr2 = ws2.NamedRanges.ElementAt(i); - Assert.AreEqual(nr1.Ranges.ToString(), nr2.Ranges.ToString()); - Assert.AreEqual(nr1.Scope, nr2.Scope); - Assert.AreEqual(nr1.Name, nr2.Name); - Assert.AreEqual(nr1.Visible, nr2.Visible); - Assert.AreEqual(nr1.Comment, nr2.Comment); - } + Assert.AreEqual(ws1.NamedRanges.Count(), ws2.NamedRanges.Count()); + for (var i = 0; i < ws1.NamedRanges.Count(); i++) + { + var nr1 = ws1.NamedRanges.ElementAt(i); + var nr2 = ws2.NamedRanges.ElementAt(i); + Assert.AreEqual(nr1.Ranges.ToString(), nr2.Ranges.ToString()); + Assert.AreEqual(nr1.Scope, nr2.Scope); + Assert.AreEqual(nr1.Name, nr2.Name); + Assert.AreEqual(nr1.Visible, nr2.Visible); + Assert.AreEqual(nr1.Comment, nr2.Comment); } } [Test] public void CopyWorksheeInsideWorkbookMakesNamedRangesLocal() { - using (var wb1 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Range("A1:A2").AddToNamed("GLOBAL", XLScope.Workbook); - ws1.Ranges("B1:B2,D1:D2").AddToNamed("LOCAL", XLScope.Worksheet); + ws1.Range("A1:A2").AddToNamed("GLOBAL", XLScope.Workbook); + ws1.Ranges("B1:B2,D1:D2").AddToNamed("LOCAL", XLScope.Worksheet); - var ws2 = ws1.CopyTo("Copy"); + var ws2 = ws1.CopyTo("Copy"); - Assert.AreEqual(ws1.NamedRanges.Count(), ws2.NamedRanges.Count()); - for (int i = 0; i < ws1.NamedRanges.Count(); i++) - { - var nr1 = ws1.NamedRanges.ElementAt(i); - var nr2 = ws2.NamedRanges.ElementAt(i); + Assert.AreEqual(ws1.NamedRanges.Count(), ws2.NamedRanges.Count()); + for (var i = 0; i < ws1.NamedRanges.Count(); i++) + { + var nr1 = ws1.NamedRanges.ElementAt(i); + var nr2 = ws2.NamedRanges.ElementAt(i); - Assert.AreEqual(XLScope.Worksheet, nr2.Scope); + Assert.AreEqual(XLScope.Worksheet, nr2.Scope); - Assert.AreEqual(nr1.Ranges.ToString(), nr2.Ranges.ToString()); - Assert.AreEqual(nr1.Name, nr2.Name); - Assert.AreEqual(nr1.Visible, nr2.Visible); - Assert.AreEqual(nr1.Comment, nr2.Comment); - } + Assert.AreEqual(nr1.Ranges.ToString(), nr2.Ranges.ToString()); + Assert.AreEqual(nr1.Name, nr2.Name); + Assert.AreEqual(nr1.Visible, nr2.Visible); + Assert.AreEqual(nr1.Comment, nr2.Comment); } } @@ -577,135 +547,129 @@ void AssertStylesAreEqual(IXLWorksheet ws1, IXLWorksheet ws2) [Test] public void CopyWorksheetPreservesConditionalFormats() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Range("A:A").AddConditionalFormat() - .WhenContains("0").Fill.SetBackgroundColor(XLColor.Red); - var cf = ws1.Range("B1:C2").AddConditionalFormat(); - cf.Ranges.Add(ws1.Range("D4:D5")); - cf.WhenEqualOrGreaterThan(100).Font.SetBold(); + ws1.Range("A:A").AddConditionalFormat() + .WhenContains("0").Fill.SetBackgroundColor(XLColor.Red); + var cf = ws1.Range("B1:C2").AddConditionalFormat(); + cf.Ranges.Add(ws1.Range("D4:D5")); + cf.WhenEqualOrGreaterThan(100).Font.SetBold(); - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.ConditionalFormats.Count(), ws2.ConditionalFormats.Count()); - for (int i = 0; i < ws1.ConditionalFormats.Count(); i++) + Assert.AreEqual(ws1.ConditionalFormats.Count(), ws2.ConditionalFormats.Count()); + for (var i = 0; i < ws1.ConditionalFormats.Count(); i++) + { + var original = ws1.ConditionalFormats.ElementAt(i); + var copy = ws2.ConditionalFormats.ElementAt(i); + Assert.AreEqual(original.Ranges.Count, copy.Ranges.Count); + for (var j = 0; j < original.Ranges.Count; j++) { - var original = ws1.ConditionalFormats.ElementAt(i); - var copy = ws2.ConditionalFormats.ElementAt(i); - Assert.AreEqual(original.Ranges.Count, copy.Ranges.Count); - for (int j = 0; j < original.Ranges.Count; j++) - { - Assert.AreEqual(original.Ranges.ElementAt(j).RangeAddress.ToString(XLReferenceStyle.A1, false), - copy.Ranges.ElementAt(j).RangeAddress.ToString(XLReferenceStyle.A1, false)); - } - - Assert.AreEqual((original.Style as XLStyle).Value, (copy.Style as XLStyle).Value); - Assert.AreEqual(original.Values.Single().Value.Value, copy.Values.Single().Value.Value); + Assert.AreEqual(original.Ranges.ElementAt(j).RangeAddress.ToString(XLReferenceStyle.A1, false), + copy.Ranges.ElementAt(j).RangeAddress.ToString(XLReferenceStyle.A1, false)); } + + Assert.AreEqual((original.Style as XLStyle).Value, (copy.Style as XLStyle).Value); + Assert.AreEqual(original.Values.Single().Value.Value, copy.Values.Single().Value.Value); } } [Test] public void CopyWorksheetPreservesTables() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + + ws1.Cell("A2").Value = "Name"; + ws1.Cell("B2").Value = "Count"; + ws1.Cell("A3").Value = "John Smith"; + ws1.Cell("B3").Value = 50; + ws1.Cell("A4").Value = "Ivan Ivanov"; + ws1.Cell("B4").Value = 40; + var table1 = ws1.Range("A2:B4").CreateTable("Test table 1"); + table1 + .SetShowAutoFilter(true) + .SetShowTotalsRow(true) + .SetEmphasizeFirstColumn(true) + .SetShowColumnStripes(true) + .SetShowRowStripes(true); + table1.Theme = XLTableTheme.TableStyleDark8; + table1.Field(1).TotalsRowFunction = XLTotalsRowFunction.Sum; + + var ws2 = ws1.CopyTo(wb2, "Copy"); + + Assert.AreEqual(ws1.Tables.Count(), ws2.Tables.Count()); + for (var i = 0; i < ws1.Tables.Count(); i++) { - var ws1 = wb1.Worksheets.Add("Original"); - - ws1.Cell("A2").Value = "Name"; - ws1.Cell("B2").Value = "Count"; - ws1.Cell("A3").Value = "John Smith"; - ws1.Cell("B3").Value = 50; - ws1.Cell("A4").Value = "Ivan Ivanov"; - ws1.Cell("B4").Value = 40; - var table1 = ws1.Range("A2:B4").CreateTable("Test table 1"); - table1 - .SetShowAutoFilter(true) - .SetShowTotalsRow(true) - .SetEmphasizeFirstColumn(true) - .SetShowColumnStripes(true) - .SetShowRowStripes(true); - table1.Theme = XLTableTheme.TableStyleDark8; - table1.Field(1).TotalsRowFunction = XLTotalsRowFunction.Sum; - - var ws2 = ws1.CopyTo(wb2, "Copy"); - - Assert.AreEqual(ws1.Tables.Count(), ws2.Tables.Count()); - for (int i = 0; i < ws1.Tables.Count(); i++) + var original = ws1.Tables.ElementAt(i); + var copy = ws2.Tables.ElementAt(i); + Assert.AreEqual(original.RangeAddress.ToString(XLReferenceStyle.A1, false), copy.RangeAddress.ToString(XLReferenceStyle.A1, false)); + Assert.AreEqual(original.Fields.Count(), copy.Fields.Count()); + for (var j = 0; j < original.Fields.Count(); j++) { - var original = ws1.Tables.ElementAt(i); - var copy = ws2.Tables.ElementAt(i); - Assert.AreEqual(original.RangeAddress.ToString(XLReferenceStyle.A1, false), copy.RangeAddress.ToString(XLReferenceStyle.A1, false)); - Assert.AreEqual(original.Fields.Count(), copy.Fields.Count()); - for (int j = 0; j < original.Fields.Count(); j++) - { - var originalField = original.Fields.ElementAt(j); - var copyField = copy.Fields.ElementAt(j); - Assert.AreEqual(originalField.Name, copyField.Name); - Assert.AreEqual(originalField.TotalsRowFormulaA1, copyField.TotalsRowFormulaA1); - Assert.AreEqual(originalField.TotalsRowFunction, copyField.TotalsRowFunction); - } - - Assert.AreEqual(original.Name, copy.Name); - Assert.AreEqual(original.ShowAutoFilter, copy.ShowAutoFilter); - Assert.AreEqual(original.ShowColumnStripes, copy.ShowColumnStripes); - Assert.AreEqual(original.ShowHeaderRow, copy.ShowHeaderRow); - Assert.AreEqual(original.ShowRowStripes, copy.ShowRowStripes); - Assert.AreEqual(original.ShowTotalsRow, copy.ShowTotalsRow); - Assert.AreEqual((original.Style as XLStyle).Value, (copy.Style as XLStyle).Value); - Assert.AreEqual(original.Theme, copy.Theme); + var originalField = original.Fields.ElementAt(j); + var copyField = copy.Fields.ElementAt(j); + Assert.AreEqual(originalField.Name, copyField.Name); + Assert.AreEqual(originalField.TotalsRowFormulaA1, copyField.TotalsRowFormulaA1); + Assert.AreEqual(originalField.TotalsRowFunction, copyField.TotalsRowFunction); } + + Assert.AreEqual(original.Name, copy.Name); + Assert.AreEqual(original.ShowAutoFilter, copy.ShowAutoFilter); + Assert.AreEqual(original.ShowColumnStripes, copy.ShowColumnStripes); + Assert.AreEqual(original.ShowHeaderRow, copy.ShowHeaderRow); + Assert.AreEqual(original.ShowRowStripes, copy.ShowRowStripes); + Assert.AreEqual(original.ShowTotalsRow, copy.ShowTotalsRow); + Assert.AreEqual((original.Style as XLStyle).Value, (copy.Style as XLStyle).Value); + Assert.AreEqual(original.Theme, copy.Theme); } } [Test] public void CopyWorksheetPreservesDataValidation() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + + var dv1 = ws1.Range("A:A").CreateDataValidation(); + dv1.WholeNumber.EqualTo(2); + dv1.ErrorStyle = XLErrorStyle.Warning; + dv1.ErrorTitle = "Number out of range"; + dv1.ErrorMessage = "This cell only allows the number 2."; + + var dv2 = ws1.Ranges("B2:C3,D4:E5").CreateDataValidation(); + dv2.Decimal.GreaterThan(5); + dv2.ErrorStyle = XLErrorStyle.Stop; + dv2.ErrorTitle = "Decimal number out of range"; + dv2.ErrorMessage = "This cell only allows decimals greater than 5."; + + var dv3 = ws1.Cell("D1").CreateDataValidation(); + dv3.TextLength.EqualOrLessThan(10); + dv3.ErrorStyle = XLErrorStyle.Information; + dv3.ErrorTitle = "Text length out of range"; + dv3.ErrorMessage = "You entered more than 10 characters."; + + var ws2 = ws1.CopyTo(wb2, "Copy"); + + Assert.AreEqual(ws1.DataValidations.Count(), ws2.DataValidations.Count()); + for (var i = 0; i < ws1.DataValidations.Count(); i++) { - var ws1 = wb1.Worksheets.Add("Original"); - - var dv1 = ws1.Range("A:A").CreateDataValidation(); - dv1.WholeNumber.EqualTo(2); - dv1.ErrorStyle = XLErrorStyle.Warning; - dv1.ErrorTitle = "Number out of range"; - dv1.ErrorMessage = "This cell only allows the number 2."; - - var dv2 = ws1.Ranges("B2:C3,D4:E5").CreateDataValidation(); - dv2.Decimal.GreaterThan(5); - dv2.ErrorStyle = XLErrorStyle.Stop; - dv2.ErrorTitle = "Decimal number out of range"; - dv2.ErrorMessage = "This cell only allows decimals greater than 5."; - - var dv3 = ws1.Cell("D1").CreateDataValidation(); - dv3.TextLength.EqualOrLessThan(10); - dv3.ErrorStyle = XLErrorStyle.Information; - dv3.ErrorTitle = "Text length out of range"; - dv3.ErrorMessage = "You entered more than 10 characters."; - - var ws2 = ws1.CopyTo(wb2, "Copy"); - - Assert.AreEqual(ws1.DataValidations.Count(), ws2.DataValidations.Count()); - for (int i = 0; i < ws1.DataValidations.Count(); i++) - { - var original = ws1.DataValidations.ElementAt(i); - var copy = ws2.DataValidations.ElementAt(i); - - var originalRanges = string.Join(",", original.Ranges.Select(r => r.RangeAddress.ToString())); - var copyRanges = string.Join(",", original.Ranges.Select(r => r.RangeAddress.ToString())); - - Assert.AreEqual(originalRanges, copyRanges); - Assert.AreEqual(original.AllowedValues, copy.AllowedValues); - Assert.AreEqual(original.Operator, copy.Operator); - Assert.AreEqual(original.ErrorStyle, copy.ErrorStyle); - Assert.AreEqual(original.ErrorTitle, copy.ErrorTitle); - Assert.AreEqual(original.ErrorMessage, copy.ErrorMessage); - } + var original = ws1.DataValidations.ElementAt(i); + var copy = ws2.DataValidations.ElementAt(i); + + var originalRanges = string.Join(",", original.Ranges.Select(r => r.RangeAddress.ToString())); + var copyRanges = string.Join(",", original.Ranges.Select(r => r.RangeAddress.ToString())); + + Assert.AreEqual(originalRanges, copyRanges); + Assert.AreEqual(original.AllowedValues, copy.AllowedValues); + Assert.AreEqual(original.Operator, copy.Operator); + Assert.AreEqual(original.ErrorStyle, copy.ErrorStyle); + Assert.AreEqual(original.ErrorTitle, copy.ErrorTitle); + Assert.AreEqual(original.ErrorMessage, copy.ErrorMessage); } } @@ -715,7 +679,7 @@ public void CopyWorksheetPreservesPictures() using (var ms = new MemoryStream()) using (var resourceStream = Assembly.GetAssembly(typeof(ClosedXML.Examples.BasicTable)) .GetManifestResourceStream("ClosedXML.Examples.Resources.SampleImage.jpg")) - using (var bitmap = Bitmap.FromStream(resourceStream) as Bitmap) + using (var bitmap = SKCodec.Create(resourceStream)) using (var wb1 = new XLWorkbook()) { var ws1 = wb1.Worksheets.Add("Original"); @@ -741,9 +705,9 @@ public void CopyWorksheetPreservesPictures() void AssertPicturesAreEqual(IXLWorksheet ws1, IXLWorksheet ws2) { - Assert.AreEqual(ws1.Pictures.Count(), ws2.Pictures.Count()); + Assert.AreEqual(ws1.Pictures.Count, ws2.Pictures.Count); - for (int i = 0; i < ws1.Pictures.Count(); i++) + for (var i = 0; i < ws1.Pictures.Count; i++) { var original = ws1.Pictures.ElementAt(i); var copy = ws2.Pictures.ElementAt(i); @@ -797,7 +761,7 @@ void AssertPivotTablesAreEqual(IXLWorksheet ws1, IXLWorksheet ws2) var comparer = new PivotTableComparer(); - for (int i = 0; i < ws1.PivotTables.Count(); i++) + for (var i = 0; i < ws1.PivotTables.Count(); i++) { var original = ws1.PivotTables.ElementAt(i).CastTo(); var copy = ws2.PivotTables.ElementAt(i).CastTo(); @@ -813,421 +777,383 @@ void AssertPivotTablesAreEqual(IXLWorksheet ws1, IXLWorksheet ws2) [Test] public void CopyWorksheetPreservesSelectedRanges() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.SelectedRanges.RemoveAll(); - ws1.SelectedRanges.Add(ws1.Range("E12:H20")); - ws1.SelectedRanges.Add(ws1.Range("B:B")); - ws1.SelectedRanges.Add(ws1.Range("3:6")); + ws1.SelectedRanges.RemoveAll(); + ws1.SelectedRanges.Add(ws1.Range("E12:H20")); + ws1.SelectedRanges.Add(ws1.Range("B:B")); + ws1.SelectedRanges.Add(ws1.Range("3:6")); - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual(ws1.SelectedRanges.Count, ws2.SelectedRanges.Count); - for (int i = 0; i < ws1.SelectedRanges.Count; i++) - { - Assert.AreEqual(ws1.SelectedRanges.ElementAt(i).RangeAddress.ToString(), - ws2.SelectedRanges.ElementAt(i).RangeAddress.ToString()); - } + Assert.AreEqual(ws1.SelectedRanges.Count, ws2.SelectedRanges.Count); + for (var i = 0; i < ws1.SelectedRanges.Count; i++) + { + Assert.AreEqual(ws1.SelectedRanges.ElementAt(i).RangeAddress.ToString(), + ws2.SelectedRanges.ElementAt(i).RangeAddress.ToString()); } } [Test] public void CopyWorksheetPreservesPageSetup() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); - - ws1.PageSetup.AddHorizontalPageBreak(15); - ws1.PageSetup.AddVerticalPageBreak(5); - ws1.PageSetup - .SetBlackAndWhite() - .SetCenterHorizontally() - .SetCenterVertically() - .SetFirstPageNumber(200) - .SetPageOrientation(XLPageOrientation.Landscape) - .SetPaperSize(XLPaperSize.A5Paper) - .SetScale(89) - .SetShowGridlines() - .SetHorizontalDpi(200) - .SetVerticalDpi(300) - .SetPagesTall(5) - .SetPagesWide(2) - .SetColumnsToRepeatAtLeft(1, 3); - ws1.PageSetup.PrintAreas.Clear(); - ws1.PageSetup.PrintAreas.Add("A1:Z200"); - ws1.PageSetup.Margins.SetBottom(5).SetTop(6).SetLeft(7).SetRight(8).SetFooter(9).SetHeader(10); - ws1.PageSetup.Header.Left.AddText(XLHFPredefinedText.FullPath, XLHFOccurrence.AllPages); - ws1.PageSetup.Footer.Right.AddText(XLHFPredefinedText.PageNumber, XLHFOccurrence.OddPages); - - var ws2 = ws1.CopyTo(wb2, "Copy"); - - Assert.AreEqual(ws1.PageSetup.FirstRowToRepeatAtTop, ws2.PageSetup.FirstRowToRepeatAtTop); - Assert.AreEqual(ws1.PageSetup.LastRowToRepeatAtTop, ws2.PageSetup.LastRowToRepeatAtTop); - Assert.AreEqual(ws1.PageSetup.FirstColumnToRepeatAtLeft, ws2.PageSetup.FirstColumnToRepeatAtLeft); - Assert.AreEqual(ws1.PageSetup.LastColumnToRepeatAtLeft, ws2.PageSetup.LastColumnToRepeatAtLeft); - Assert.AreEqual(ws1.PageSetup.PageOrientation, ws2.PageSetup.PageOrientation); - Assert.AreEqual(ws1.PageSetup.PagesWide, ws2.PageSetup.PagesWide); - Assert.AreEqual(ws1.PageSetup.PagesTall, ws2.PageSetup.PagesTall); - Assert.AreEqual(ws1.PageSetup.Scale, ws2.PageSetup.Scale); - Assert.AreEqual(ws1.PageSetup.HorizontalDpi, ws2.PageSetup.HorizontalDpi); - Assert.AreEqual(ws1.PageSetup.VerticalDpi, ws2.PageSetup.VerticalDpi); - Assert.AreEqual(ws1.PageSetup.FirstPageNumber, ws2.PageSetup.FirstPageNumber); - Assert.AreEqual(ws1.PageSetup.CenterHorizontally, ws2.PageSetup.CenterHorizontally); - Assert.AreEqual(ws1.PageSetup.CenterVertically, ws2.PageSetup.CenterVertically); - Assert.AreEqual(ws1.PageSetup.PaperSize, ws2.PageSetup.PaperSize); - Assert.AreEqual(ws1.PageSetup.Margins.Bottom, ws2.PageSetup.Margins.Bottom); - Assert.AreEqual(ws1.PageSetup.Margins.Top, ws2.PageSetup.Margins.Top); - Assert.AreEqual(ws1.PageSetup.Margins.Left, ws2.PageSetup.Margins.Left); - Assert.AreEqual(ws1.PageSetup.Margins.Right, ws2.PageSetup.Margins.Right); - Assert.AreEqual(ws1.PageSetup.Margins.Footer, ws2.PageSetup.Margins.Footer); - Assert.AreEqual(ws1.PageSetup.Margins.Header, ws2.PageSetup.Margins.Header); - Assert.AreEqual(ws1.PageSetup.ScaleHFWithDocument, ws2.PageSetup.ScaleHFWithDocument); - Assert.AreEqual(ws1.PageSetup.AlignHFWithMargins, ws2.PageSetup.AlignHFWithMargins); - Assert.AreEqual(ws1.PageSetup.ShowGridlines, ws2.PageSetup.ShowGridlines); - Assert.AreEqual(ws1.PageSetup.ShowRowAndColumnHeadings, ws2.PageSetup.ShowRowAndColumnHeadings); - Assert.AreEqual(ws1.PageSetup.BlackAndWhite, ws2.PageSetup.BlackAndWhite); - Assert.AreEqual(ws1.PageSetup.DraftQuality, ws2.PageSetup.DraftQuality); - Assert.AreEqual(ws1.PageSetup.PageOrder, ws2.PageSetup.PageOrder); - Assert.AreEqual(ws1.PageSetup.ShowComments, ws2.PageSetup.ShowComments); - Assert.AreEqual(ws1.PageSetup.PrintErrorValue, ws2.PageSetup.PrintErrorValue); - - Assert.AreEqual(ws1.PageSetup.PrintAreas.Count(), ws2.PageSetup.PrintAreas.Count()); - - Assert.AreEqual(ws1.PageSetup.Header.Left.GetText(XLHFOccurrence.AllPages), ws2.PageSetup.Header.Left.GetText(XLHFOccurrence.AllPages)); - Assert.AreEqual(ws1.PageSetup.Footer.Right.GetText(XLHFOccurrence.OddPages), ws2.PageSetup.Footer.Right.GetText(XLHFOccurrence.OddPages)); - } + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + + ws1.PageSetup.AddHorizontalPageBreak(15); + ws1.PageSetup.AddVerticalPageBreak(5); + ws1.PageSetup + .SetBlackAndWhite() + .SetCenterHorizontally() + .SetCenterVertically() + .SetFirstPageNumber(200) + .SetPageOrientation(XLPageOrientation.Landscape) + .SetPaperSize(XLPaperSize.A5Paper) + .SetScale(89) + .SetShowGridlines() + .SetHorizontalDpi(200) + .SetVerticalDpi(300) + .SetPagesTall(5) + .SetPagesWide(2) + .SetColumnsToRepeatAtLeft(1, 3); + ws1.PageSetup.PrintAreas.Clear(); + ws1.PageSetup.PrintAreas.Add("A1:Z200"); + ws1.PageSetup.Margins.SetBottom(5).SetTop(6).SetLeft(7).SetRight(8).SetFooter(9).SetHeader(10); + ws1.PageSetup.Header.Left.AddText(XLHFPredefinedText.FullPath, XLHFOccurrence.AllPages); + ws1.PageSetup.Footer.Right.AddText(XLHFPredefinedText.PageNumber, XLHFOccurrence.OddPages); + + var ws2 = ws1.CopyTo(wb2, "Copy"); + + Assert.AreEqual(ws1.PageSetup.FirstRowToRepeatAtTop, ws2.PageSetup.FirstRowToRepeatAtTop); + Assert.AreEqual(ws1.PageSetup.LastRowToRepeatAtTop, ws2.PageSetup.LastRowToRepeatAtTop); + Assert.AreEqual(ws1.PageSetup.FirstColumnToRepeatAtLeft, ws2.PageSetup.FirstColumnToRepeatAtLeft); + Assert.AreEqual(ws1.PageSetup.LastColumnToRepeatAtLeft, ws2.PageSetup.LastColumnToRepeatAtLeft); + Assert.AreEqual(ws1.PageSetup.PageOrientation, ws2.PageSetup.PageOrientation); + Assert.AreEqual(ws1.PageSetup.PagesWide, ws2.PageSetup.PagesWide); + Assert.AreEqual(ws1.PageSetup.PagesTall, ws2.PageSetup.PagesTall); + Assert.AreEqual(ws1.PageSetup.Scale, ws2.PageSetup.Scale); + Assert.AreEqual(ws1.PageSetup.HorizontalDpi, ws2.PageSetup.HorizontalDpi); + Assert.AreEqual(ws1.PageSetup.VerticalDpi, ws2.PageSetup.VerticalDpi); + Assert.AreEqual(ws1.PageSetup.FirstPageNumber, ws2.PageSetup.FirstPageNumber); + Assert.AreEqual(ws1.PageSetup.CenterHorizontally, ws2.PageSetup.CenterHorizontally); + Assert.AreEqual(ws1.PageSetup.CenterVertically, ws2.PageSetup.CenterVertically); + Assert.AreEqual(ws1.PageSetup.PaperSize, ws2.PageSetup.PaperSize); + Assert.AreEqual(ws1.PageSetup.Margins.Bottom, ws2.PageSetup.Margins.Bottom); + Assert.AreEqual(ws1.PageSetup.Margins.Top, ws2.PageSetup.Margins.Top); + Assert.AreEqual(ws1.PageSetup.Margins.Left, ws2.PageSetup.Margins.Left); + Assert.AreEqual(ws1.PageSetup.Margins.Right, ws2.PageSetup.Margins.Right); + Assert.AreEqual(ws1.PageSetup.Margins.Footer, ws2.PageSetup.Margins.Footer); + Assert.AreEqual(ws1.PageSetup.Margins.Header, ws2.PageSetup.Margins.Header); + Assert.AreEqual(ws1.PageSetup.ScaleHFWithDocument, ws2.PageSetup.ScaleHFWithDocument); + Assert.AreEqual(ws1.PageSetup.AlignHFWithMargins, ws2.PageSetup.AlignHFWithMargins); + Assert.AreEqual(ws1.PageSetup.ShowGridlines, ws2.PageSetup.ShowGridlines); + Assert.AreEqual(ws1.PageSetup.ShowRowAndColumnHeadings, ws2.PageSetup.ShowRowAndColumnHeadings); + Assert.AreEqual(ws1.PageSetup.BlackAndWhite, ws2.PageSetup.BlackAndWhite); + Assert.AreEqual(ws1.PageSetup.DraftQuality, ws2.PageSetup.DraftQuality); + Assert.AreEqual(ws1.PageSetup.PageOrder, ws2.PageSetup.PageOrder); + Assert.AreEqual(ws1.PageSetup.ShowComments, ws2.PageSetup.ShowComments); + Assert.AreEqual(ws1.PageSetup.PrintErrorValue, ws2.PageSetup.PrintErrorValue); + + Assert.AreEqual(ws1.PageSetup.PrintAreas.Count(), ws2.PageSetup.PrintAreas.Count()); + + Assert.AreEqual(ws1.PageSetup.Header.Left.GetText(XLHFOccurrence.AllPages), ws2.PageSetup.Header.Left.GetText(XLHFOccurrence.AllPages)); + Assert.AreEqual(ws1.PageSetup.Footer.Right.GetText(XLHFOccurrence.OddPages), ws2.PageSetup.Footer.Right.GetText(XLHFOccurrence.OddPages)); } [Test] public void CopyWorksheetPreservesSparklineGroups() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); + var original = ws1.SparklineGroups.Add("A1:A10", "D1:Z10") + .SetDateRange(ws1.Range("D11:Z11")) + .SetDisplayEmptyCellsAs(XLDisplayBlanksAsValues.Zero) + .SetDisplayHidden(true) + .SetLineWeight(1.5) + .SetShowMarkers(XLSparklineMarkers.All) + .SetStyle(XLSparklineTheme.Colorful3) + .SetType(XLSparklineType.Column); + + original.HorizontalAxis + .SetColor(XLColor.Blue) + .SetRightToLeft(true) + .SetVisible(true); + + original.VerticalAxis + .SetManualMin(-100.0) + .SetManualMax(100.0); + + var ws2 = ws1.CopyTo(wb2, "Copy"); + + Assert.AreEqual(1, ws2.SparklineGroups.Count()); + var copy = ws2.SparklineGroups.Single(); + + Assert.AreEqual(original.Count(), copy.Count()); + for (var i = 0; i < original.Count(); i++) { - var ws1 = wb1.Worksheets.Add("Original"); - var original = ws1.SparklineGroups.Add("A1:A10", "D1:Z10") - .SetDateRange(ws1.Range("D11:Z11")) - .SetDisplayEmptyCellsAs(XLDisplayBlanksAsValues.Zero) - .SetDisplayHidden(true) - .SetLineWeight(1.5) - .SetShowMarkers(XLSparklineMarkers.All) - .SetStyle(XLSparklineTheme.Colorful3) - .SetType(XLSparklineType.Column); - - original.HorizontalAxis - .SetColor(XLColor.Blue) - .SetRightToLeft(true) - .SetVisible(true); - - original.VerticalAxis - .SetManualMin(-100.0) - .SetManualMax(100.0); - - var ws2 = ws1.CopyTo(wb2, "Copy"); - - Assert.AreEqual(1, ws2.SparklineGroups.Count()); - var copy = ws2.SparklineGroups.Single(); - - Assert.AreEqual(original.Count(), copy.Count()); - for (int i = 0; i < original.Count(); i++) - { - Assert.AreSame(ws2, copy.ElementAt(i).Location.Worksheet); - Assert.AreSame(ws2, copy.ElementAt(i).SourceData.Worksheet); - Assert.AreEqual(original.ElementAt(i).Location.Address.ToString(), copy.ElementAt(i).Location.Address.ToString()); - Assert.AreEqual(original.ElementAt(i).SourceData.RangeAddress.ToString(), copy.ElementAt(i).SourceData.RangeAddress.ToString()); - } - - Assert.AreEqual(original.DateRange.RangeAddress.ToString(), copy.DateRange.RangeAddress.ToString()); - Assert.AreSame(ws2, copy.DateRange.Worksheet); - - Assert.AreEqual(original.DisplayEmptyCellsAs, copy.DisplayEmptyCellsAs); - Assert.AreEqual(original.DisplayHidden, copy.DisplayHidden); - Assert.AreEqual(original.LineWeight, copy.LineWeight, XLHelper.Epsilon); - Assert.AreEqual(original.ShowMarkers, copy.ShowMarkers); - Assert.AreEqual(original.Style, copy.Style); - Assert.AreNotSame(original.Style, copy.Style); - Assert.AreEqual(original.Type, copy.Type); - - Assert.AreEqual(original.HorizontalAxis.Color, copy.HorizontalAxis.Color); - Assert.AreEqual(original.HorizontalAxis.DateAxis, copy.HorizontalAxis.DateAxis); - Assert.AreEqual(original.HorizontalAxis.IsVisible, copy.HorizontalAxis.IsVisible); - Assert.AreEqual(original.HorizontalAxis.RightToLeft, copy.HorizontalAxis.RightToLeft); - - Assert.AreEqual(original.VerticalAxis.ManualMax, copy.VerticalAxis.ManualMax); - Assert.AreEqual(original.VerticalAxis.ManualMin, copy.VerticalAxis.ManualMin); - Assert.AreEqual(original.VerticalAxis.MaxAxisType, copy.VerticalAxis.MaxAxisType); - Assert.AreEqual(original.VerticalAxis.MinAxisType, copy.VerticalAxis.MinAxisType); + Assert.AreSame(ws2, copy.ElementAt(i).Location.Worksheet); + Assert.AreSame(ws2, copy.ElementAt(i).SourceData.Worksheet); + Assert.AreEqual(original.ElementAt(i).Location.Address.ToString(), copy.ElementAt(i).Location.Address.ToString()); + Assert.AreEqual(original.ElementAt(i).SourceData.RangeAddress.ToString(), copy.ElementAt(i).SourceData.RangeAddress.ToString()); } + + Assert.AreEqual(original.DateRange.RangeAddress.ToString(), copy.DateRange.RangeAddress.ToString()); + Assert.AreSame(ws2, copy.DateRange.Worksheet); + + Assert.AreEqual(original.DisplayEmptyCellsAs, copy.DisplayEmptyCellsAs); + Assert.AreEqual(original.DisplayHidden, copy.DisplayHidden); + Assert.AreEqual(original.LineWeight, copy.LineWeight, XLHelper.Epsilon); + Assert.AreEqual(original.ShowMarkers, copy.ShowMarkers); + Assert.AreEqual(original.Style, copy.Style); + Assert.AreNotSame(original.Style, copy.Style); + Assert.AreEqual(original.Type, copy.Type); + + Assert.AreEqual(original.HorizontalAxis.Color, copy.HorizontalAxis.Color); + Assert.AreEqual(original.HorizontalAxis.DateAxis, copy.HorizontalAxis.DateAxis); + Assert.AreEqual(original.HorizontalAxis.IsVisible, copy.HorizontalAxis.IsVisible); + Assert.AreEqual(original.HorizontalAxis.RightToLeft, copy.HorizontalAxis.RightToLeft); + + Assert.AreEqual(original.VerticalAxis.ManualMax, copy.VerticalAxis.ManualMax); + Assert.AreEqual(original.VerticalAxis.ManualMin, copy.VerticalAxis.ManualMin); + Assert.AreEqual(original.VerticalAxis.MaxAxisType, copy.VerticalAxis.MaxAxisType); + Assert.AreEqual(original.VerticalAxis.MinAxisType, copy.VerticalAxis.MinAxisType); } [Test, Ignore("Muted until #836 is fixed")] public void CopyWorksheetChangesAbsoluteReferencesInFormulae() { - using (var wb1 = new XLWorkbook()) - using (var wb2 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + using var wb2 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Cell("A1").FormulaA1 = "10*10"; - ws1.Cell("A2").FormulaA1 = "Original!A1 * 3"; + ws1.Cell("A1").FormulaA1 = "10*10"; + ws1.Cell("A2").FormulaA1 = "Original!A1 * 3"; - var ws2 = ws1.CopyTo(wb2, "Copy"); + var ws2 = ws1.CopyTo(wb2, "Copy"); - Assert.AreEqual("Copy!A1 * 3", ws2.Cell("A2").FormulaA1); - } + Assert.AreEqual("Copy!A1 * 3", ws2.Cell("A2").FormulaA1); } [Test, Ignore("Muted until #836 is fixed")] public void RenameWorksheetChangesAbsoluteReferencesInFormulae() { - using (var wb1 = new XLWorkbook()) - { - var ws1 = wb1.Worksheets.Add("Original"); + using var wb1 = new XLWorkbook(); + var ws1 = wb1.Worksheets.Add("Original"); - ws1.Cell("A1").FormulaA1 = "10*10"; - ws1.Cell("A2").FormulaA1 = "Original!A1 * 3"; + ws1.Cell("A1").FormulaA1 = "10*10"; + ws1.Cell("A2").FormulaA1 = "Original!A1 * 3"; - ws1.Name = "Renamed"; + ws1.Name = "Renamed"; - Assert.AreEqual("Renamed!A1 * 3", ws1.Cell("A2").FormulaA1); - } + Assert.AreEqual("Renamed!A1 * 3", ws1.Cell("A2").FormulaA1); } [Test] public void RangesFromDeletedWorksheetContainREF() { - using (var wb1 = new XLWorkbook()) - { - wb1.Worksheets.Add("Sheet1"); - var ws2 = wb1.Worksheets.Add("Sheet2"); - var range = ws2.Range("A1:B2"); + using var wb1 = new XLWorkbook(); + wb1.Worksheets.Add("Sheet1"); + var ws2 = wb1.Worksheets.Add("Sheet2"); + var range = ws2.Range("A1:B2"); - ws2.Delete(); + ws2.Delete(); - Assert.AreEqual("#REF!A1:B2", range.RangeAddress.ToString()); - } + Assert.AreEqual("#REF!A1:B2", range.RangeAddress.ToString()); } [Test] public void InvalidRowAndColumnIndices() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - Assert.Throws(() => ws.Row(-1)); - Assert.Throws(() => ws.Row(XLHelper.MaxRowNumber + 1)); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + Assert.Throws(() => ws.Row(-1)); + Assert.Throws(() => ws.Row(XLHelper.MaxRowNumber + 1)); - Assert.Throws(() => ws.Column(-1)); - Assert.Throws(() => ws.Column(XLHelper.MaxColumnNumber + 1)); - } + Assert.Throws(() => ws.Column(-1)); + Assert.Throws(() => ws.Column(XLHelper.MaxColumnNumber + 1)); } [Test] public void InvalidSelectedRangeExcluded() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - var range1 = ws.Range("B2:C2"); - var range2 = ws.Range("B4:C4"); - ws.SelectedRanges.Clear(); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var range1 = ws.Range("B2:C2"); + var range2 = ws.Range("B4:C4"); + ws.SelectedRanges.Clear(); - ws.SelectedRanges.Add(range1); - ws.SelectedRanges.Add(range2); + ws.SelectedRanges.Add(range1); + ws.SelectedRanges.Add(range2); - ws.Row(4).Delete(); + ws.Row(4).Delete(); - Assert.IsFalse(range2.RangeAddress.IsValid); - Assert.AreEqual(range1, ws.SelectedRanges.Single()); - } + Assert.IsFalse(range2.RangeAddress.IsValid); + Assert.AreEqual(range1, ws.SelectedRanges.Single()); } [Test] public void InsertColumnsDoesNotIncreaseCellsCount() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell("AAA50"); - var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell("AAA50"); + var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - ws.Column(1).InsertColumnsBefore(1); + ws.Column(1).InsertColumnsBefore(1); - Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void InsertRowsDoesNotIncreaseCellsCount() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell("AAA500"); - var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell("AAA500"); + var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - ws.Row(1).InsertRowsAbove(1); + ws.Row(1).InsertRowsAbove(1); - Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void InsertCellsBeforeDoesNotIncreaseCellsCount() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell("AAA50"); - var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell("AAA50"); + var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - cell1.InsertCellsBefore(1); + cell1.InsertCellsBefore(1); - Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void InsertCellsAboveDoesNotIncreaseCellsCount() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell("AAA500"); - var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell("AAA500"); + var originalCount = (ws as XLWorksheet).Internals.CellsCollection.Count; - cell1.InsertCellsAbove(1); + cell1.InsertCellsAbove(1); - Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + Assert.AreEqual(originalCount, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void CellsShiftedTooFarRightArePurged() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell(1, XLHelper.MaxColumnNumber); - var cell3 = ws.Cell(2, XLHelper.MaxColumnNumber); - - cell1.InsertCellsBefore(1); - Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); - ws.Column(1).InsertColumnsBefore(1); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell(1, XLHelper.MaxColumnNumber); + var cell3 = ws.Cell(2, XLHelper.MaxColumnNumber); + + cell1.InsertCellsBefore(1); + Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); + ws.Column(1).InsertColumnsBefore(1); + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void CellsShiftedTooFarDownArePurged() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A1"); - var cell2 = ws.Cell(XLHelper.MaxRowNumber, 1); - var cell3 = ws.Cell(XLHelper.MaxRowNumber, 2); - - cell1.InsertCellsAbove(1); - Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); - ws.Row(1).InsertRowsAbove(1); - Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); - } + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A1"); + var cell2 = ws.Cell(XLHelper.MaxRowNumber, 1); + var cell3 = ws.Cell(XLHelper.MaxRowNumber, 2); + + cell1.InsertCellsAbove(1); + Assert.AreEqual(2, (ws as XLWorksheet).Internals.CellsCollection.Count); + ws.Row(1).InsertRowsAbove(1); + Assert.AreEqual(1, (ws as XLWorksheet).Internals.CellsCollection.Count); } [Test] public void MaxColumnUsedUpdatedWhenColumnDeleted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("C1"); - var cell2 = ws.Cell(1, XLHelper.MaxColumnNumber); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("C1"); + var cell2 = ws.Cell(1, XLHelper.MaxColumnNumber); - ws.Column(XLHelper.MaxColumnNumber).Delete(); + ws.Column(XLHelper.MaxColumnNumber).Delete(); - Assert.AreEqual(3, (ws as XLWorksheet).Internals.CellsCollection.MaxColumnUsed); - } + Assert.AreEqual(3, (ws as XLWorksheet).Internals.CellsCollection.MaxColumnUsed); } [Test] public void MaxRowUsedUpdatedWhenRowDeleted() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet(); - var cell1 = ws.Cell("A3"); - var cell2 = ws.Cell(XLHelper.MaxRowNumber, 1); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet(); + var cell1 = ws.Cell("A3"); + var cell2 = ws.Cell(XLHelper.MaxRowNumber, 1); - ws.Row(XLHelper.MaxRowNumber).Delete(); + ws.Row(XLHelper.MaxRowNumber).Delete(); - Assert.AreEqual(3, (ws as XLWorksheet).Internals.CellsCollection.MaxRowUsed); - } + Assert.AreEqual(3, (ws as XLWorksheet).Internals.CellsCollection.MaxRowUsed); } [Test] public void ChangeColumnStyleFirst() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("ColumnFirst"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("ColumnFirst"); - ws.Column(2).Style.Font.SetBold(true); - ws.Row(2).Style.Font.SetItalic(true); + ws.Column(2).Style.Font.SetBold(true); + ws.Row(2).Style.Font.SetItalic(true); - Assert.IsTrue(ws.Cell("B2").Style.Font.Bold); - Assert.IsTrue(ws.Cell("B2").Style.Font.Italic); - } + Assert.IsTrue(ws.Cell("B2").Style.Font.Bold); + Assert.IsTrue(ws.Cell("B2").Style.Font.Italic); } [Test] public void ChangeRowStyleFirst() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("RowFirst"); + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("RowFirst"); - ws.Row(2).Style.Font.SetItalic(true); - ws.Column(2).Style.Font.SetBold(true); + ws.Row(2).Style.Font.SetItalic(true); + ws.Column(2).Style.Font.SetBold(true); - Assert.IsTrue(ws.Cell("B2").Style.Font.Bold); - Assert.IsTrue(ws.Cell("B2").Style.Font.Italic); - } + Assert.IsTrue(ws.Cell("B2").Style.Font.Bold); + Assert.IsTrue(ws.Cell("B2").Style.Font.Italic); } [Test] public void SelectedTabIsActive_WhenInsertBefore() { - using (var ms = new MemoryStream()) + using var ms = new MemoryStream(); + using (var wb = new XLWorkbook()) { - using (var wb = new XLWorkbook()) - { - var ws1 = wb.AddWorksheet(); - ws1.TabSelected = true; - var ws2 = wb.Worksheets.Add(1); - wb.SaveAs(ms); - } + var ws1 = wb.AddWorksheet(); + ws1.TabSelected = true; + var ws2 = wb.Worksheets.Add(1); + wb.SaveAs(ms); + } - using (var wb = new XLWorkbook(ms)) - { - var ws1 = wb.Worksheets.First(); - var ws2 = wb.Worksheets.Last(); + using (var wb = new XLWorkbook(ms)) + { + var ws1 = wb.Worksheets.First(); + var ws2 = wb.Worksheets.Last(); - Assert.IsFalse(ws1.TabActive); - Assert.IsFalse(ws1.TabSelected); - Assert.IsTrue(ws2.TabActive); - Assert.IsTrue(ws2.TabSelected); - } + Assert.IsFalse(ws1.TabActive); + Assert.IsFalse(ws1.TabSelected); + Assert.IsTrue(ws2.TabActive); + Assert.IsTrue(ws2.TabSelected); } } @@ -1235,12 +1161,10 @@ public void SelectedTabIsActive_WhenInsertBefore() [TestCase("noactive_twoselected.xlsx")] public void FirstSheetIsActive_WhenNotSpecified(string fileName) { - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\NoActiveSheet\" + fileName))) - using (var wb = new XLWorkbook(stream)) - { - Assert.IsTrue(wb.Worksheets.First().TabActive); - Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheets.First().Visibility); - } + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Other\NoActiveSheet\" + fileName)); + using var wb = new XLWorkbook(stream); + Assert.IsTrue(wb.Worksheets.First().TabActive); + Assert.AreEqual(XLWorksheetVisibility.Visible, wb.Worksheets.First().Visibility); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/ExcelDocsComparerTests.cs b/ClosedXML.Tests/ExcelDocsComparerTests.cs index 782bf8928..9e738e88a 100644 --- a/ClosedXML.Tests/ExcelDocsComparerTests.cs +++ b/ClosedXML.Tests/ExcelDocsComparerTests.cs @@ -1,4 +1,5 @@ using ClosedXML.Examples; +using ClosedXML.Tests.Utils; using NUnit.Framework; using System.IO; @@ -10,13 +11,13 @@ public class ExcelDocsComparerTests [Test] public void CheckEqual() { - string left = ExampleHelper.GetTempFilePath("left.xlsx"); - string right = ExampleHelper.GetTempFilePath("right.xlsx"); + var left = ExampleHelper.GetTempFilePath("left.xlsx"); + var right = ExampleHelper.GetTempFilePath("right.xlsx"); try { new BasicTable().Create(left); new BasicTable().Create(right); - Assert.IsTrue(ExcelDocsComparer.Compare(left, right, out string message)); + Assert.IsTrue(ExcelDocsComparer.Compare(left, right, out var message)); } finally { @@ -34,14 +35,14 @@ public void CheckEqual() [Test] public void CheckNonEqual() { - string left = ExampleHelper.GetTempFilePath("left.xlsx"); - string right = ExampleHelper.GetTempFilePath("right.xlsx"); + var left = ExampleHelper.GetTempFilePath("left.xlsx"); + var right = ExampleHelper.GetTempFilePath("right.xlsx"); try { new BasicTable().Create(left); new HelloWorld().Create(right); - Assert.IsFalse(ExcelDocsComparer.Compare(left, right, out string message)); + Assert.IsFalse(ExcelDocsComparer.Compare(left, right, out var message)); } finally { @@ -56,4 +57,4 @@ public void CheckNonEqual() } } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Extensions/EnumerableExtensionsTests.cs b/ClosedXML.Tests/Extensions/EnumerableExtensionsTests.cs index 5e92e5e53..08a52f53a 100644 --- a/ClosedXML.Tests/Extensions/EnumerableExtensionsTests.cs +++ b/ClosedXML.Tests/Extensions/EnumerableExtensionsTests.cs @@ -1,5 +1,5 @@ using ClosedXML.Excel; -using ClosedXML.Tests.Excel; +using ClosedXML.Tests.Excel.Tables; using NUnit.Framework; using System.Collections; using System.Collections.Generic; diff --git a/ClosedXML.Tests/Extensions/FontBaseExtensionsTests.cs b/ClosedXML.Tests/Extensions/FontBaseExtensionsTests.cs new file mode 100644 index 000000000..242f0de77 --- /dev/null +++ b/ClosedXML.Tests/Extensions/FontBaseExtensionsTests.cs @@ -0,0 +1,102 @@ +using ClosedXML.Excel; +using ClosedXML.Extensions; +using NUnit.Framework; +using SkiaSharp; +using System.Collections.Generic; + +namespace ClosedXML.Tests.Extensions +{ + public class FontBaseExtensionsTests + { + private const string FontAvaliableOnMostOs = "DejaVu Serif"; + + [Test] + [Platform("Win", Reason = "Expectation only fits windows system because the font calibri isn't available on other OSs")] + [TestCase(20, 26.25, 4)] + [TestCase(150, 164, 10)] + public void ShouldGetHeightUsingCalibriFont(int fontSize, double expectedHeight, int toleratedDiff) + { + var fontCache = new Dictionary(); + + var xLFont = new XLFont + { + FontSize = fontSize, + FontName = "Calibri" + }; + + MissingCalibriTestGuard(xLFont); + + var actualHeight = xLFont.GetHeight(fontCache); + Assert.AreEqual(expectedHeight, actualHeight, toleratedDiff); + } + + [Test] + [TestCase(20, 27.5, 3)] + [TestCase(200, 249.75d, 10)] + public void ShouldGetHeightUsingOsAgnosticFriendlyFont(int fontSize, double expectedHeight, int toleratedDiff) + { + var fontCache = new Dictionary(); + + var xLFont = new XLFont + { + FontSize = fontSize, + FontName = FontAvaliableOnMostOs + }; + + var actualHeight = xLFont.GetHeight(fontCache); + Assert.AreEqual(expectedHeight, actualHeight, toleratedDiff); + } + + [Test] + [Platform("Win", Reason = "Expectation only fits windows system because the font calibri isn't available on other OSs")] + [TestCase(200, "X", 29.57)] + [TestCase(20, "Very Wide Column", 30.43)] + [TestCase(72, "BigText", 43)] + [TestCase(8, "SmallText", 6)] + [TestCase(11, "LongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongTextLongText", 226.57)] + public void ShouldGetWidthCalibriFont(int fontSize, string text, double expectedWidth) + { + var fontCache = new Dictionary(); + + var xLFont = new XLFont + { + FontSize = fontSize, + FontName = "Calibri" + }; + + MissingCalibriTestGuard(xLFont); + + var actualWidth = xLFont.GetWidth(text, fontCache); + Assert.AreEqual(expectedWidth, actualWidth, 3); + } + + private static void MissingCalibriTestGuard(XLFont xLFont) + { + using var fontManager = SKFontManager.CreateDefault(); + var typeface = fontManager.MatchFamily(xLFont.FontName); + if (typeface == null) + { + Assert.Inconclusive("Could not find font Calibri on test host, skipping test"); + } + } + + [Test] + [TestCase(200, "X", 38.29, 4)] + [TestCase(20, "Very Wide Column", 36.8, 2)] + [TestCase(72, "BigText", 51.29, 5)] + [TestCase(8, "SmallText", 8.9, 2)] + public void ShouldGetWidthUsingOsAgnosticFriendlyFont(int fontSize, string text, double expectedFontSize, int tolerance) + { + var fontCache = new Dictionary(); + + var xLFont = new XLFont + { + FontSize = fontSize, + FontName = FontAvaliableOnMostOs + }; + + var actualWidth = xLFont.GetWidth(text, fontCache); + Assert.AreEqual(expectedFontSize, actualWidth, tolerance); + } + } +} \ No newline at end of file diff --git a/ClosedXML.Tests/Extensions/ReflectionExtensionTests.cs b/ClosedXML.Tests/Extensions/ReflectionExtensionTests.cs index 59fa6a56e..b3afc6b16 100644 --- a/ClosedXML.Tests/Extensions/ReflectionExtensionTests.cs +++ b/ClosedXML.Tests/Extensions/ReflectionExtensionTests.cs @@ -15,10 +15,16 @@ static TestClass() } public static int StaticProperty { get; set; } +#pragma warning disable 0649 public static int StaticField; +#pragma warning restore 0649 + +#pragma warning disable 0067 public static event EventHandler StaticEvent; +#pragma warning restore 0067 + public static void StaticMethod() { } @@ -30,10 +36,16 @@ public TestClass() } public int InstanceProperty { get; set; } +#pragma warning disable 0649 public int InstanceField; +#pragma warning restore 0649 + +#pragma warning disable 0067 public event EventHandler InstanceEvent; +#pragma warning restore 0067 + public void InstanceMethod() { } diff --git a/ClosedXML.Tests/OleDb/OleDbTests.cs b/ClosedXML.Tests/OleDb/OleDbTests.cs index 13d3900dc..89f254782 100644 --- a/ClosedXML.Tests/OleDb/OleDbTests.cs +++ b/ClosedXML.Tests/OleDb/OleDbTests.cs @@ -1,13 +1,14 @@ -#if !APPVEYOR && _NETFRAMEWORK_ -using ClosedXML.Excel; +using ClosedXML.Excel; using ClosedXML.Tests.Utils; using NUnit.Framework; using System; using System.Collections.Generic; using System.Data; using System.Data.OleDb; +using System.Globalization; using System.IO; using System.Linq; +using System.Threading; namespace ClosedXML.Tests.OleDb { @@ -15,49 +16,77 @@ namespace ClosedXML.Tests.OleDb public class OleDbTests { [Test] + [Platform("NET")] + [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "Using NUnit platform filter to achieve that this test does only run on .net4.x")] public void TestOleDbValues() { - using (var tf = new TemporaryFile(CreateTestFile())) + using var tf = new TemporaryFile(CreateTestFile()); + Console.Write("Using temporary file\t{0}", tf.Path); + var connectionString = string.Format(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties='Excel 12.0 Xml;HDR=YES;IMEX=1';", tf.Path); + using var connection = new OleDbConnection(connectionString); + var currentUserCulture = Thread.CurrentThread.CurrentCulture; + var currentUserUiCulture = Thread.CurrentThread.CurrentUICulture; + try { - Console.Write("Using temporary file\t{0}", tf.Path); - var connectionString = string.Format(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties='Excel 12.0 Xml;HDR=YES;IMEX=1';", tf.Path); - using (var connection = new OleDbConnection(connectionString)) + Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US"); + Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); + + // Install driver from https://www.microsoft.com/en-za/download/details.aspx?id=13255 if required + // Also check that test runner is running under correct architecture: + try { - // Install driver from https://www.microsoft.com/en-za/download/details.aspx?id=13255 if required - // Also check that test runner is running under correct architecture: connection.Open(); - using (var command = new OleDbCommand("select * from [Sheet1$]", connection)) - using (var dataAdapter = new OleDbDataAdapter()) + } + catch (InvalidOperationException excpetion) + { + if (excpetion.Message == "The 'Microsoft.ACE.OLEDB.12.0' provider is not registered on the local machine.") { - dataAdapter.SelectCommand = command; - var dt = new DataTable(); - dataAdapter.Fill(dt); + Assert.Ignore("Install driver from https://www.microsoft.com/en-za/download/details.aspx?id=13255"); + } + else + { + throw; + } + } + } + finally + { + Thread.CurrentThread.CurrentCulture = currentUserCulture; + Thread.CurrentThread.CurrentUICulture = currentUserUiCulture; + } - Assert.AreEqual("Base", dt.Columns[0].ColumnName); - Assert.AreEqual("Ref", dt.Columns[1].ColumnName); + using (var command = new OleDbCommand("select * from [Sheet1$]", connection)) + using (var dataAdapter = new OleDbDataAdapter()) + { + dataAdapter.SelectCommand = command; + using var dt = new DataTable(); + dataAdapter.Fill(dt); - Assert.AreEqual(2, dt.Rows.Count); + Assert.AreEqual("Base", dt.Columns[0].ColumnName); + Assert.AreEqual("Ref", dt.Columns[1].ColumnName); - Assert.AreEqual(42, dt.Rows.Cast().First()[0]); - Assert.AreEqual(42, dt.Rows.Cast().First()[1]); + Assert.AreEqual(2, dt.Rows.Count); - Assert.AreEqual(41, dt.Rows.Cast().Last()[0]); - Assert.AreEqual(41, dt.Rows.Cast().Last()[1]); - } + Assert.AreEqual(42, dt.Rows.Cast().First()[0]); + Assert.AreEqual(42, dt.Rows.Cast().First()[1]); - using (var command = new OleDbCommand("select * from [Sheet2$]", connection)) - using (var dataAdapter = new OleDbDataAdapter()) - { - dataAdapter.SelectCommand = command; - var dt = new DataTable(); - dataAdapter.Fill(dt); + Assert.AreEqual(41, dt.Rows.Cast().Last()[0]); + Assert.AreEqual(41, dt.Rows.Cast().Last()[1]); + } + + using (var command = new OleDbCommand("select * from [Sheet2$]", connection)) + using (var dataAdapter = new OleDbDataAdapter()) + { + dataAdapter.SelectCommand = command; + using var dt = new DataTable(); + dataAdapter.Fill(dt); - Assert.AreEqual("Ref1", dt.Columns[0].ColumnName); - Assert.AreEqual("Ref2", dt.Columns[1].ColumnName); - Assert.AreEqual("Sum", dt.Columns[2].ColumnName); - Assert.AreEqual("SumRef", dt.Columns[3].ColumnName); + Assert.AreEqual("Ref1", dt.Columns[0].ColumnName); + Assert.AreEqual("Ref2", dt.Columns[1].ColumnName); + Assert.AreEqual("Sum", dt.Columns[2].ColumnName); + Assert.AreEqual("SumRef", dt.Columns[3].ColumnName); - var expected = new Dictionary() + var expected = new Dictionary() { {"Ref1", 42 }, {"Ref2", 41 }, @@ -65,56 +94,53 @@ public void TestOleDbValues() {"SumRef", 83 }, }; - foreach (var col in dt.Columns.Cast()) - foreach (var row in dt.Rows.Cast()) - { - Assert.AreEqual(expected[col.ColumnName], row[col]); - } - - Assert.AreEqual(2, dt.Rows.Count); + foreach (var col in dt.Columns.Cast()) + { + foreach (var row in dt.Rows.Cast()) + { + Assert.AreEqual(expected[col.ColumnName], row[col]); } - - connection.Close(); } + + Assert.AreEqual(2, dt.Rows.Count); } + + connection.Close(); } private string CreateTestFile() { - using (var wb = new XLWorkbook()) - { - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = "Base"; - ws.Cell("B1").Value = "Ref"; + using var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = "Base"; + ws.Cell("B1").Value = "Ref"; - ws.Cell("A2").Value = 42; - ws.Cell("A3").Value = 41; + ws.Cell("A2").Value = 42; + ws.Cell("A3").Value = 41; - ws.Cell("B2").FormulaA1 = "=A2"; - ws.Cell("B3").FormulaA1 = "=A3"; + ws.Cell("B2").FormulaA1 = "=A2"; + ws.Cell("B3").FormulaA1 = "=A3"; - ws = wb.AddWorksheet("Sheet2"); - ws.Cell("A1").Value = "Ref1"; - ws.Cell("B1").Value = "Ref2"; - ws.Cell("C1").Value = "Sum"; - ws.Cell("D1").Value = "SumRef"; + ws = wb.AddWorksheet("Sheet2"); + ws.Cell("A1").Value = "Ref1"; + ws.Cell("B1").Value = "Ref2"; + ws.Cell("C1").Value = "Sum"; + ws.Cell("D1").Value = "SumRef"; - ws.Cell("A2").FormulaA1 = "=Sheet1!A2"; - ws.Cell("B2").FormulaA1 = "=Sheet1!A3"; - ws.Cell("C2").FormulaA1 = "=SUM(A2:B2)"; - ws.Cell("D2").FormulaA1 = "=SUM(Sheet1!A2:Sheet1!A3)"; + ws.Cell("A2").FormulaA1 = "=Sheet1!A2"; + ws.Cell("B2").FormulaA1 = "=Sheet1!A3"; + ws.Cell("C2").FormulaA1 = "=SUM(A2:B2)"; + ws.Cell("D2").FormulaA1 = "=SUM(Sheet1!A2:Sheet1!A3)"; - ws.Cell("A3").FormulaA1 = "=Sheet1!B2"; - ws.Cell("B3").FormulaA1 = "=Sheet1!B3"; - ws.Cell("C3").FormulaA1 = "=SUM(A3:B3)"; - ws.Cell("D3").FormulaA1 = "=SUM(Sheet1!B2:Sheet1!B3)"; + ws.Cell("A3").FormulaA1 = "=Sheet1!B2"; + ws.Cell("B3").FormulaA1 = "=Sheet1!B3"; + ws.Cell("C3").FormulaA1 = "=SUM(A3:B3)"; + ws.Cell("D3").FormulaA1 = "=SUM(Sheet1!B2:Sheet1!B3)"; - var path = Path.ChangeExtension(Path.GetTempFileName(), "xlsx"); - wb.SaveAs(path, true, true); + var path = Path.ChangeExtension(Path.GetTempFileName(), "xlsx"); + wb.SaveAs(path, true, true); - return path; - } + return path; } } -} -#endif +} \ No newline at end of file diff --git a/ClosedXML.Tests/OpenXmlTests.cs b/ClosedXML.Tests/OpenXmlTests.cs index 0552fdfc4..5cf564222 100644 --- a/ClosedXML.Tests/OpenXmlTests.cs +++ b/ClosedXML.Tests/OpenXmlTests.cs @@ -8,23 +8,14 @@ namespace ClosedXML.Tests public class OpenXmlTests { [Test] - [Ignore("Workaround has been included in ClosedXML")] public static void SetPackagePropertiesEntryToNullWithOpenXml() { - // Fixed in .NET Standard 2.1 - // See: - // https://github.com/OfficeDev/Open-XML-SDK/issues/235 - // https://github.com/dotnet/corefx/issues/23795 - using (var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx"))) - using (var ms = new MemoryStream()) - { - stream.CopyTo(ms); + using var stream = TestHelper.GetStreamFromResource(TestHelper.GetResourcePath(@"Examples\PivotTables\PivotTables.xlsx")); + using var ms = new MemoryStream(); + stream.CopyTo(ms); - using (var document = SpreadsheetDocument.Open(ms, true)) - { - document.PackageProperties.Creator = null; - } - } + using var document = SpreadsheetDocument.Open(ms, true); + document.PackageProperties.Creator = null; } } } diff --git a/ClosedXML.Tests/Resource/Examples/AutoFilter/CustomAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/AutoFilter/CustomAutoFilter.xlsx index 156af429a..ed0910c8c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/AutoFilter/CustomAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/AutoFilter/CustomAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/AutoFilter/DateTimeGroupAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/AutoFilter/DateTimeGroupAutoFilter.xlsx index f251dd5a1..f1ce60de3 100644 Binary files a/ClosedXML.Tests/Resource/Examples/AutoFilter/DateTimeGroupAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/AutoFilter/DateTimeGroupAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/AutoFilter/DynamicAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/AutoFilter/DynamicAutoFilter.xlsx index ca266742d..62e2f7ea9 100644 Binary files a/ClosedXML.Tests/Resource/Examples/AutoFilter/DynamicAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/AutoFilter/DynamicAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/AutoFilter/RegularAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/AutoFilter/RegularAutoFilter.xlsx index 08b4b9d6b..a71778703 100644 Binary files a/ClosedXML.Tests/Resource/Examples/AutoFilter/RegularAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/AutoFilter/RegularAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/AutoFilter/TopBottomAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/AutoFilter/TopBottomAutoFilter.xlsx index e3963457e..62a08a1c8 100644 Binary files a/ClosedXML.Tests/Resource/Examples/AutoFilter/TopBottomAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/AutoFilter/TopBottomAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Columns/ColumnCells.xlsx b/ClosedXML.Tests/Resource/Examples/Columns/ColumnCells.xlsx index 70c8e964d..cc148a377 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Columns/ColumnCells.xlsx and b/ClosedXML.Tests/Resource/Examples/Columns/ColumnCells.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Columns/ColumnCollection.xlsx b/ClosedXML.Tests/Resource/Examples/Columns/ColumnCollection.xlsx index be26acad1..41d90a0f0 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Columns/ColumnCollection.xlsx and b/ClosedXML.Tests/Resource/Examples/Columns/ColumnCollection.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Columns/ColumnSettings.xlsx b/ClosedXML.Tests/Resource/Examples/Columns/ColumnSettings.xlsx index ea65770a0..a697ab59b 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Columns/ColumnSettings.xlsx and b/ClosedXML.Tests/Resource/Examples/Columns/ColumnSettings.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Columns/DeletingColumns.xlsx b/ClosedXML.Tests/Resource/Examples/Columns/DeletingColumns.xlsx index f430cbf67..d3a6eb2bc 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Columns/DeletingColumns.xlsx and b/ClosedXML.Tests/Resource/Examples/Columns/DeletingColumns.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Comments/AddingComments.xlsx b/ClosedXML.Tests/Resource/Examples/Comments/AddingComments.xlsx index dde44468e..a9bdc7731 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Comments/AddingComments.xlsx and b/ClosedXML.Tests/Resource/Examples/Comments/AddingComments.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFBottom.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFBottom.xlsx index 09f3a9fa0..a3145469c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFBottom.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFBottom.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowHigh.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowHigh.xlsx index 80e81a737..2c526b01c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowHigh.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowHigh.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowMidHigh.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowMidHigh.xlsx index 797dc0b91..0fb0e32ab 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowMidHigh.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleLowMidHigh.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleMinimumMaximum.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleMinimumMaximum.xlsx index e58bfc1f2..36bf3befd 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleMinimumMaximum.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFColorScaleMinimumMaximum.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFContains.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFContains.xlsx index 8e4adf15d..27b478149 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFContains.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFContains.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBar.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBar.xlsx index 3ea2dc37c..9a2f0d154 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBar.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBar.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBarNegative.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBarNegative.xlsx index a8c97a8d6..da08686b9 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBarNegative.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBarNegative.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBars.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBars.xlsx index 67dd2331e..393372e93 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBars.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDataBars.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDatesOccurring.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDatesOccurring.xlsx index 5593abf9e..d0948ce39 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDatesOccurring.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFDatesOccurring.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEndsWith.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEndsWith.xlsx index 80d08b70a..f560246cd 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEndsWith.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEndsWith.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsNumber.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsNumber.xlsx index 13f828d98..3ecbe4325 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsNumber.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsNumber.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsString.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsString.xlsx index 8a256372c..fbee0be01 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsString.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFEqualsString.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIconSet.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIconSet.xlsx index 0ef237762..bd97c9123 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIconSet.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIconSet.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsBlank.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsBlank.xlsx index e6fa5ec07..59069fb85 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsBlank.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsBlank.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsError.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsError.xlsx index ad1c538f9..0e2fd38bf 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsError.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFIsError.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFMultipleConditions.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFMultipleConditions.xlsx index 73bb45756..fde1fec9e 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFMultipleConditions.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFMultipleConditions.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotBlank.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotBlank.xlsx index 8861be419..686b28466 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotBlank.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotBlank.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotContains.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotContains.xlsx index 865670121..befae3429 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotContains.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotContains.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsNumber.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsNumber.xlsx index 6e23b6a97..fedf4135c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsNumber.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsNumber.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsString.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsString.xlsx index d39adb068..f5b124824 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsString.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotEqualsString.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotError.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotError.xlsx index 1ca013100..57d5837bb 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotError.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFNotError.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStartsWith.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStartsWith.xlsx index cc432eb15..e17b3e9e5 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStartsWith.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStartsWith.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStopIfTrue.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStopIfTrue.xlsx index de67d1ef9..aae73d2bf 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStopIfTrue.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFStopIfTrue.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFTop.xlsx b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFTop.xlsx index 27182d071..6e966c5f7 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFTop.xlsx and b/ClosedXML.Tests/Resource/Examples/ConditionalFormatting/CFTop.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Delete/DeleteFewWorksheets.xlsx b/ClosedXML.Tests/Resource/Examples/Delete/DeleteFewWorksheets.xlsx index df718c9df..a46276f11 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Delete/DeleteFewWorksheets.xlsx and b/ClosedXML.Tests/Resource/Examples/Delete/DeleteFewWorksheets.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Delete/RemoveRows.xlsx b/ClosedXML.Tests/Resource/Examples/Delete/RemoveRows.xlsx index 31ef95484..491cd56d7 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Delete/RemoveRows.xlsx and b/ClosedXML.Tests/Resource/Examples/Delete/RemoveRows.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx b/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx index 40e2d5d36..b47b72354 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx and b/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageAnchors.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx b/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx index ecd11cac2..7d8c6145b 100644 Binary files a/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx and b/ClosedXML.Tests/Resource/Examples/ImageHandling/ImageFormats.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Loading/ChangingBasicTable.xlsx b/ClosedXML.Tests/Resource/Examples/Loading/ChangingBasicTable.xlsx index 891cfca49..6add23c0d 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Loading/ChangingBasicTable.xlsx and b/ClosedXML.Tests/Resource/Examples/Loading/ChangingBasicTable.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/AddingDataSet.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/AddingDataSet.xlsx index 91e6370ee..0011c0ac0 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/AddingDataSet.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/AddingDataSet.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/AddingDataTableAsWorksheet.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/AddingDataTableAsWorksheet.xlsx index e63a0507e..843002996 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/AddingDataTableAsWorksheet.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/AddingDataTableAsWorksheet.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContents.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContents.xlsx index 7c902ac1e..050b23ff1 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContents.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContents.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContentsWithAutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContentsWithAutoFilter.xlsx index cbc64658a..39b89fdac 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContentsWithAutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/AdjustToContentsWithAutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/AutoFilter.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/AutoFilter.xlsx index da9b21ded..9ae3e0021 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/AutoFilter.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/AutoFilter.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/BasicTable.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/BasicTable.xlsx index 62fbfa58f..2ec560cc3 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/BasicTable.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/BasicTable.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/BlankCells.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/BlankCells.xlsx index 6c5eccc51..53dd9e2f9 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/BlankCells.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/BlankCells.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/CellValues.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/CellValues.xlsx index e73de6b1a..e81579cb5 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/CellValues.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/CellValues.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/Collections.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/Collections.xlsx index b5626972f..fbd288d67 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/Collections.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/Collections.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/CopyingRowsAndColumns.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/CopyingRowsAndColumns.xlsx index 003632024..aa02d125f 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/CopyingRowsAndColumns.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/CopyingRowsAndColumns.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/CopyingWorksheets.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/CopyingWorksheets.xlsx index fa8895397..639c6ade1 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/CopyingWorksheets.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/CopyingWorksheets.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataTypes.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataTypes.xlsx index ace078093..6461af388 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataTypes.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataTypes.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataTypesUnderDifferentCulture.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataTypesUnderDifferentCulture.xlsx index b68d6493b..d5a7960a3 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataTypesUnderDifferentCulture.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataTypesUnderDifferentCulture.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidation.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidation.xlsx index 92f455b78..c8c192f9e 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidation.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidation.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDate.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDate.xlsx index e7fa2c4ad..3c27996e4 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDate.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDate.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDecimal.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDecimal.xlsx index 298e410db..5f572f631 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDecimal.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationDecimal.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTextLength.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTextLength.xlsx index 08057dfb5..88c651f61 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTextLength.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTextLength.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTime.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTime.xlsx index 3ab7e01ba..60bcc334b 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTime.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationTime.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationWholeNumber.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationWholeNumber.xlsx index a24d9f05e..fcdb072f4 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/DataValidationWholeNumber.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/DataValidationWholeNumber.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/Formulas.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/Formulas.xlsx index 513d951d1..9a533f1c5 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/Formulas.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/Formulas.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/FormulasWithEvaluation.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/FormulasWithEvaluation.xlsx index 7cb0a2abb..f3df32db3 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/FormulasWithEvaluation.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/FormulasWithEvaluation.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/FreezePanes.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/FreezePanes.xlsx index 5110cc227..9566cfba6 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/FreezePanes.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/FreezePanes.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/HideSheets.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/HideSheets.xlsx index 2587ee657..0aa092465 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/HideSheets.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/HideSheets.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/HideUnhide.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/HideUnhide.xlsx index f2d07a568..1533b7f6b 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/HideUnhide.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/HideUnhide.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/Hyperlinks.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/Hyperlinks.xlsx index a4ab6f609..3069b34f8 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/Hyperlinks.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/Hyperlinks.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/InsertingData.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/InsertingData.xlsx index eb57e22c4..9329ffe67 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/InsertingData.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/InsertingData.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/InsertingDataNetFramework.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/InsertingDataNetFramework.xlsx new file mode 100644 index 000000000..8bd51c750 Binary files /dev/null and b/ClosedXML.Tests/Resource/Examples/Misc/InsertingDataNetFramework.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/LambdaExpressions.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/LambdaExpressions.xlsx index 0466c97fa..876652476 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/LambdaExpressions.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/LambdaExpressions.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/MergeCells.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/MergeCells.xlsx index edb7c877f..14447257e 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/MergeCells.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/MergeCells.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/MergeMoves.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/MergeMoves.xlsx index 56fd1ccd0..0abf674f5 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/MergeMoves.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/MergeMoves.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/Outline.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/Outline.xlsx index 9c90baa4e..4fb2c25e9 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/Outline.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/Outline.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/RightToLeft.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/RightToLeft.xlsx index 1017afde9..8ccd34ca6 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/RightToLeft.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/RightToLeft.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/SheetProtection.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/SheetProtection.xlsx index 05bb3dfd1..676508875 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/SheetProtection.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/SheetProtection.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/SheetViews.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/SheetViews.xlsx index fd6a7797f..03eaaea1f 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/SheetViews.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/SheetViews.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/ShiftingFormulas.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/ShiftingFormulas.xlsx index 377c23e64..4ad88fe1f 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/ShiftingFormulas.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/ShiftingFormulas.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/ShowCase.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/ShowCase.xlsx index ba6e0517a..ba8404b02 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/ShowCase.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/ShowCase.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/TabColors.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/TabColors.xlsx index 5c5545591..bac93cb76 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/TabColors.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/TabColors.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProperties.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProperties.xlsx index 969d71bba..bbf076473 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProperties.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProperties.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProtection.xlsx b/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProtection.xlsx index 5dea2d722..60776a705 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProtection.xlsx and b/ClosedXML.Tests/Resource/Examples/Misc/WorkbookProtection.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/HeaderFooters.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/HeaderFooters.xlsx index f0d73743c..8fbb821aa 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/HeaderFooters.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/HeaderFooters.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/Margins.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/Margins.xlsx index 2f6805bc8..6e9d5083c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/Margins.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/Margins.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/Page.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/Page.xlsx index c55e060df..1915067e8 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/Page.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/Page.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/SheetTab.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/SheetTab.xlsx index 30bfbccdc..bba1e4367 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/SheetTab.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/SheetTab.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/Sheets.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/Sheets.xlsx index 2ac5d1dbe..1154130d0 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/Sheets.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/Sheets.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PageSetup/TwoPages.xlsx b/ClosedXML.Tests/Resource/Examples/PageSetup/TwoPages.xlsx index 6096e008f..b42dff6dc 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PageSetup/TwoPages.xlsx and b/ClosedXML.Tests/Resource/Examples/PageSetup/TwoPages.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/PivotTables/PivotTables.xlsx b/ClosedXML.Tests/Resource/Examples/PivotTables/PivotTables.xlsx index ed2d986f3..9fa1a78c0 100644 Binary files a/ClosedXML.Tests/Resource/Examples/PivotTables/PivotTables.xlsx and b/ClosedXML.Tests/Resource/Examples/PivotTables/PivotTables.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/AddingRowToTables.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/AddingRowToTables.xlsx index 29ece6a73..87363102d 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/AddingRowToTables.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/AddingRowToTables.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/ClearingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/ClearingRanges.xlsx index 9b8602f87..cc01e3702 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/ClearingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/ClearingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/CopyingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/CopyingRanges.xlsx index 0fe825b7d..3cd4e97c3 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/CopyingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/CopyingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/CurrentRowColumn.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/CurrentRowColumn.xlsx index 44ebfb8ea..d73387c2a 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/CurrentRowColumn.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/CurrentRowColumn.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/DefiningRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/DefiningRanges.xlsx index b1ac96fde..1b3b4c9ee 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/DefiningRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/DefiningRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/DeletingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/DeletingRanges.xlsx index 1289e3523..3dcbb4b1b 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/DeletingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/DeletingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingColumns.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingColumns.xlsx index 0b175443b..07513b05c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingColumns.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingColumns.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingRows.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingRows.xlsx index bfafa6573..f96c6e958 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingRows.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/InsertingDeletingRows.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/MultipleRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/MultipleRanges.xlsx index b0621bcbd..b50ec7ebf 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/MultipleRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/MultipleRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/NamedRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/NamedRanges.xlsx index a4a86dac7..23941d1ab 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/NamedRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/NamedRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/SelectingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/SelectingRanges.xlsx index 2c8936858..d26cdd7f2 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/SelectingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/SelectingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/ShiftingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/ShiftingRanges.xlsx index 7098270a5..db88fecd2 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/ShiftingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/ShiftingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/SortExample.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/SortExample.xlsx index 7f8ea3972..1ef44a887 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/SortExample.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/SortExample.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/Sorting.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/Sorting.xlsx index 5227d406e..8c29618e6 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/Sorting.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/Sorting.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRanges.xlsx index 9805bc158..4033c6690 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRangesPlus.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRangesPlus.xlsx index 347f8c500..94562e5a2 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRangesPlus.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/TransposeRangesPlus.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Ranges/WalkingRanges.xlsx b/ClosedXML.Tests/Resource/Examples/Ranges/WalkingRanges.xlsx index 1b82a8fab..b3997cdc0 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Ranges/WalkingRanges.xlsx and b/ClosedXML.Tests/Resource/Examples/Ranges/WalkingRanges.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Rows/RowCells.xlsx b/ClosedXML.Tests/Resource/Examples/Rows/RowCells.xlsx index f7a57c8e4..8adeccb96 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Rows/RowCells.xlsx and b/ClosedXML.Tests/Resource/Examples/Rows/RowCells.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Rows/RowCollection.xlsx b/ClosedXML.Tests/Resource/Examples/Rows/RowCollection.xlsx index 885535492..a75df6519 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Rows/RowCollection.xlsx and b/ClosedXML.Tests/Resource/Examples/Rows/RowCollection.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Rows/RowSettings.xlsx b/ClosedXML.Tests/Resource/Examples/Rows/RowSettings.xlsx index 457bb9972..4a6def5e9 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Rows/RowSettings.xlsx and b/ClosedXML.Tests/Resource/Examples/Rows/RowSettings.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Sparklines/SampleSparklines.xlsx b/ClosedXML.Tests/Resource/Examples/Sparklines/SampleSparklines.xlsx index 8f4b947a0..5c7233240 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Sparklines/SampleSparklines.xlsx and b/ClosedXML.Tests/Resource/Examples/Sparklines/SampleSparklines.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/DefaultStyles.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/DefaultStyles.xlsx index 9e9a109e5..7485e9678 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/DefaultStyles.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/DefaultStyles.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/PurpleWorksheet.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/PurpleWorksheet.xlsx index ea00b0c9e..1b9053d8d 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/PurpleWorksheet.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/PurpleWorksheet.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleAlignment.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleAlignment.xlsx index ec3232fdb..cb87fc9f6 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleAlignment.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleAlignment.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleBorder.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleBorder.xlsx index bc0189809..18dd05087 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleBorder.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleBorder.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleFill.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleFill.xlsx index 9e192029d..6d4c5692c 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleFill.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleFill.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleFont.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleFont.xlsx index af7d4b492..4a9096fab 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleFont.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleFont.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleIncludeQuotePrefix.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleIncludeQuotePrefix.xlsx index 2a8640263..814f16475 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleIncludeQuotePrefix.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleIncludeQuotePrefix.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleNumberFormat.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleNumberFormat.xlsx index 23184a36c..b86c91297 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleNumberFormat.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleNumberFormat.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleRowsColumns.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleRowsColumns.xlsx index fdadbd38c..6bd01a093 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleRowsColumns.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleRowsColumns.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/StyleWorksheet.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/StyleWorksheet.xlsx index c7f065291..59edee0c7 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/StyleWorksheet.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/StyleWorksheet.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/UsingColors.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/UsingColors.xlsx index 2d49b85c3..b9f2ca224 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/UsingColors.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/UsingColors.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/UsingPhonetics.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/UsingPhonetics.xlsx index b334a6d64..a4d46e04a 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/UsingPhonetics.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/UsingPhonetics.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Styles/UsingRichText.xlsx b/ClosedXML.Tests/Resource/Examples/Styles/UsingRichText.xlsx index b83ccdecc..75e85bfe1 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Styles/UsingRichText.xlsx and b/ClosedXML.Tests/Resource/Examples/Styles/UsingRichText.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Tables/InsertingTables.xlsx b/ClosedXML.Tests/Resource/Examples/Tables/InsertingTables.xlsx index 929b38bbf..72fb5ee04 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Tables/InsertingTables.xlsx and b/ClosedXML.Tests/Resource/Examples/Tables/InsertingTables.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Tables/ResizingTables.xlsx b/ClosedXML.Tests/Resource/Examples/Tables/ResizingTables.xlsx index c8874b993..f44bc51d2 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Tables/ResizingTables.xlsx and b/ClosedXML.Tests/Resource/Examples/Tables/ResizingTables.xlsx differ diff --git a/ClosedXML.Tests/Resource/Examples/Tables/UsingTables.xlsx b/ClosedXML.Tests/Resource/Examples/Tables/UsingTables.xlsx index 70bdab774..a934b6382 100644 Binary files a/ClosedXML.Tests/Resource/Examples/Tables/UsingTables.xlsx and b/ClosedXML.Tests/Resource/Examples/Tables/UsingTables.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/BlankPivotTableField/BlankPivotTableField.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/BlankPivotTableField/BlankPivotTableField.xlsx index a3b61968c..26ff64267 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/BlankPivotTableField/BlankPivotTableField.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/BlankPivotTableField/BlankPivotTableField.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/PivotTableWithNoneTheme/outputfile.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/PivotTableWithNoneTheme/outputfile.xlsx index 3fbd2417b..38e683f3c 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/PivotTableWithNoneTheme/outputfile.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/PivotTableWithNoneTheme/outputfile.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/SourceSheetWithWhitespace/outputfile.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/SourceSheetWithWhitespace/outputfile.xlsx index 6a72c39a7..d4f8093f3 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/SourceSheetWithWhitespace/outputfile.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/SourceSheetWithWhitespace/outputfile.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/input.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/input.xlsx index 7ab44e80b..d4e6f8357 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/input.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/input.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/output.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/output.xlsx index cc39e974b..cbbd682eb 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/output.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/TwoPivotTablesWithSingleSource/output.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/VersioningAttributes/outputfile.xlsx b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/VersioningAttributes/outputfile.xlsx index 64dae0a90..6cb357957 100644 Binary files a/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/VersioningAttributes/outputfile.xlsx and b/ClosedXML.Tests/Resource/Other/PivotTableReferenceFiles/VersioningAttributes/outputfile.xlsx differ diff --git a/ClosedXML.Tests/Resource/Other/StyleReferenceFiles/TransparentBackgroundFill/TransparentBackgroundFill.xlsx b/ClosedXML.Tests/Resource/Other/StyleReferenceFiles/TransparentBackgroundFill/TransparentBackgroundFill.xlsx index 8e76ffd76..c12d20680 100644 Binary files a/ClosedXML.Tests/Resource/Other/StyleReferenceFiles/TransparentBackgroundFill/TransparentBackgroundFill.xlsx and b/ClosedXML.Tests/Resource/Other/StyleReferenceFiles/TransparentBackgroundFill/TransparentBackgroundFill.xlsx differ diff --git a/ClosedXML.Tests/Resource/TryToLoad/CommentAsNoteWithNoTextBox.xlsx b/ClosedXML.Tests/Resource/TryToLoad/CommentAsNoteWithNoTextBox.xlsx new file mode 100644 index 000000000..432af55d3 Binary files /dev/null and b/ClosedXML.Tests/Resource/TryToLoad/CommentAsNoteWithNoTextBox.xlsx differ diff --git a/ClosedXML.Tests/Resource/TryToLoad/CommentFormatted.xlsx b/ClosedXML.Tests/Resource/TryToLoad/CommentFormatted.xlsx new file mode 100644 index 000000000..be26bc088 Binary files /dev/null and b/ClosedXML.Tests/Resource/TryToLoad/CommentFormatted.xlsx differ diff --git a/ClosedXML.Tests/Resource/TryToLoad/TextNull.xlsx b/ClosedXML.Tests/Resource/TryToLoad/TextNull.xlsx new file mode 100644 index 000000000..47a091bfc Binary files /dev/null and b/ClosedXML.Tests/Resource/TryToLoad/TextNull.xlsx differ diff --git a/ClosedXML.Tests/Resource/TryToLoad/ThreadedComment.xlsx b/ClosedXML.Tests/Resource/TryToLoad/ThreadedComment.xlsx new file mode 100644 index 000000000..8a457f59a Binary files /dev/null and b/ClosedXML.Tests/Resource/TryToLoad/ThreadedComment.xlsx differ diff --git a/ClosedXML.Tests/TestHelper.cs b/ClosedXML.Tests/TestHelper.cs index dd3f4fef5..151fe05d9 100644 --- a/ClosedXML.Tests/TestHelper.cs +++ b/ClosedXML.Tests/TestHelper.cs @@ -1,5 +1,6 @@ using ClosedXML.Examples; using ClosedXML.Excel; +using ClosedXML.Tests.Utils; using NUnit.Framework; using System; using System.Collections.Generic; @@ -12,19 +13,9 @@ namespace ClosedXML.Tests { internal static class TestHelper { - public static string CurrencySymbol - { - get { return Thread.CurrentThread.CurrentCulture.NumberFormat.CurrencySymbol; } - } + public static string CurrencySymbol => Thread.CurrentThread.CurrentCulture.NumberFormat.CurrencySymbol; - //Note: Run example tests parameters - public static string TestsOutputDirectory - { - get - { - return Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "Generated"); - } - } + public static string TestsOutputDirectory => Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "Generated"); public const string ActualTestResultPostFix = ""; public static readonly string ExampleTestsOutputDirectory = Path.Combine(TestsOutputDirectory, "Examples"); @@ -38,30 +29,15 @@ public static void SaveWorkbook(XLWorkbook workbook, params string[] fileNamePar workbook.SaveAs(Path.Combine(new string[] { TestsOutputDirectory }.Concat(fileNameParts).ToArray()), true); } - // Because different fonts are installed on Unix, - // the columns widths after AdjustToContents() will - // cause the tests to fail. - // Therefore we ignore the width attribute when running on Unix - public static bool StripColumnWidths { get { return IsRunningOnUnix; } } - - public static bool IsRunningOnUnix - { - get - { - int p = (int)Environment.OSVersion.Platform; - return ((p == 4) || (p == 6) || (p == 128)); - } - } - - public static void RunTestExample(string filePartName, bool evaluateFormulae = false) + public static void RunTestExample(string filePartName, bool evaluateFormula = false, string expectedDiff = null, bool ignoreColumnFormats = false) where T : IXLExample, new() { // Make sure tests run on a deterministic culture Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); var example = new T(); - string[] pathParts = filePartName.Split(new char[] { '\\' }); - string filePath1 = Path.Combine(new List() { ExampleTestsOutputDirectory }.Concat(pathParts).ToArray()); + var pathParts = filePartName.Split(new[] { '\\' }); + var filePath1 = Path.Combine(new List { ExampleTestsOutputDirectory }.Concat(pathParts).ToArray()); var extension = Path.GetExtension(filePath1); var directory = Path.GetDirectoryName(filePath1); @@ -75,38 +51,77 @@ public static void RunTestExample(string filePartName, bool evaluateFormulae //Run test example.Create(filePath1); + example.Create(filePath1); using (var wb = new XLWorkbook(filePath1)) - wb.SaveAs(filePath2, validate: true, evaluateFormulae); + { + wb.SaveAs(filePath2, validate: true, evaluateFormula); + } // Also load from template and save it again - but not necessary to test against reference file // We're just testing that it can save. using (var ms = new MemoryStream()) using (var wb = XLWorkbook.OpenFromTemplate(filePath1)) - wb.SaveAs(ms, validate: true, evaluateFormulae); + { + wb.SaveAs(ms, validate: true, evaluateFormula); + } + + // Uncomment to replace expectation running .net6.0, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("../../../", "resource", "examples", filePartName.Replace("\\", "/"))); + //File.Copy(filePath2, expectedFileInVsSolution, true); + // Uncomment to replace expectation running .net4.8, + //var expectedFileInVsSolution = Path.GetFullPath(Path.Combine("ClosedXML.Tests", "Resource", "Examples", filePartName.Replace("\\", "/"))); + //File.Copy(filePath2, expectedFileInVsSolution, true); if (CompareWithResources) { - string resourcePath = "Examples." + filePartName.Replace('\\', '.').TrimStart('.'); - using (var streamExpected = _extractor.ReadFileFromResourceToStream(resourcePath)) - using (var streamActual = File.OpenRead(filePath2)) + var resourcePath = "Examples." + filePartName.Replace('\\', '.').TrimStart('.'); + using var streamExpected = _extractor.ReadFileFromResourceToStream(resourcePath); + using var streamActual = File.OpenRead(filePath2); + var success = ExcelDocsComparer.Compare(streamActual, streamExpected, out var message, ignoreColumnFormats); + var formattedMessage = $"Actual file '{filePath2}' is different than the expected file '{resourcePath}'. The difference is: '{message}'."; + + if (success) { - var success = ExcelDocsComparer.Compare(streamActual, streamExpected, out string message); - var formattedMessage = - String.Format( - "Actual file '{0}' is different than the expected file '{1}'. The difference is: '{2}'", - filePath2, resourcePath, message); + return; + } - Assert.IsTrue(success, formattedMessage); + SaveToTestresults(streamExpected, "Expected" + resourcePath); + SaveToTestresults(streamActual, "Actual" + resourcePath); + + if (string.IsNullOrEmpty(expectedDiff)) + { + Assert.Fail(formattedMessage); } + + Assert.That(message, Is.EqualTo(expectedDiff), $"Actual diff '{message}' differs to expected diff '{expectedDiff}', file '{resourcePath}'"); } } - public static void CreateAndCompare(Func workbookGenerator, string referenceResource, bool evaluateFormulae = false) + private static void SaveToTestresults(Stream streamExpected, string filename) + { + var testResultDirectory = Path.Combine(TestsOutputDirectory, "../../../../../TestResult"); + if (!Directory.Exists(testResultDirectory)) + { + Directory.CreateDirectory(testResultDirectory); + } + streamExpected.Position = 0; + var path = Path.Combine(testResultDirectory, filename); + + if (File.Exists(path)) + { + File.Delete(path); + } + + using var expectedFile = new FileStream(path, FileMode.Create); + streamExpected.CopyTo(expectedFile); + } + + public static void CreateAndCompare(Func workbookGenerator, string referenceResource, bool evaluateFormulae = false, bool ignoreColumnFormats = false) { Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); - string[] pathParts = referenceResource.Split(new char[] { '\\' }); - string filePath1 = Path.Combine(new List() { TestsOutputDirectory }.Concat(pathParts).ToArray()); + var pathParts = referenceResource.Split(new[] { '\\' }); + var filePath1 = Path.Combine(new List { TestsOutputDirectory }.Concat(pathParts).ToArray()); var extension = Path.GetExtension(filePath1); var directory = Path.GetDirectoryName(filePath1); @@ -118,22 +133,22 @@ public static void CreateAndCompare(Func workbookGenerator, string var filePath2 = Path.Combine(directory, fileName); using (var wb = workbookGenerator.Invoke()) + { wb.SaveAs(filePath2, true, evaluateFormulae); + } if (CompareWithResources) { - string resourcePath = referenceResource.Replace('\\', '.').TrimStart('.'); - using (var streamExpected = _extractor.ReadFileFromResourceToStream(resourcePath)) - using (var streamActual = File.OpenRead(filePath2)) - { - var success = ExcelDocsComparer.Compare(streamActual, streamExpected, out string message); - var formattedMessage = - String.Format( - "Actual file '{0}' is different than the expected file '{1}'. The difference is: '{2}'", - filePath2, resourcePath, message); - - Assert.IsTrue(success, formattedMessage); - } + var resourcePath = referenceResource.Replace('\\', '.').TrimStart('.'); + using var streamExpected = _extractor.ReadFileFromResourceToStream(resourcePath); + using var streamActual = File.OpenRead(filePath2); + var success = ExcelDocsComparer.Compare(streamActual, streamExpected, out var message, ignoreColumnFormats); + var formattedMessage = + string.Format( + "Actual file '{0}' is different than the expected file '{1}'. The difference is: '{2}'", + filePath2, resourcePath, message); + + Assert.IsTrue(success, formattedMessage); } } @@ -150,15 +165,13 @@ public static Stream GetStreamFromResource(string resourcePath) public static void LoadFile(string filePartName) { IXLWorkbook wb; - using (var stream = GetStreamFromResource(GetResourcePath(filePartName))) - { - Assert.DoesNotThrow(() => wb = new XLWorkbook(stream), "Unable to load resource {0}", filePartName); - } + using var stream = GetStreamFromResource(GetResourcePath(filePartName)); + Assert.DoesNotThrow(() => wb = new XLWorkbook(stream), "Unable to load resource {0}", filePartName); } - public static IEnumerable ListResourceFiles(Func predicate = null) + public static IEnumerable ListResourceFiles(Func predicate = null) { return _extractor.GetFileNames(predicate); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Utils/ExcelDocsComparer.cs b/ClosedXML.Tests/Utils/ExcelDocsComparer.cs index f3828b5c4..32fbe9845 100644 --- a/ClosedXML.Tests/Utils/ExcelDocsComparer.cs +++ b/ClosedXML.Tests/Utils/ExcelDocsComparer.cs @@ -2,37 +2,28 @@ using System.IO; using System.IO.Packaging; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Utils { internal static class ExcelDocsComparer { public static bool Compare(string left, string right, out string message) { - using (FileStream leftStream = File.OpenRead(left)) - using (FileStream rightStream = File.OpenRead(right)) - { - return Compare(leftStream, rightStream, out message); - } + using var leftStream = File.OpenRead(left); + using var rightStream = File.OpenRead(right); + return Compare(leftStream, rightStream, out message, false); } - public static bool Compare(Stream left, Stream right, out string message) + public static bool Compare(Stream left, Stream right, out string message, bool ignoreColumnFormat) { - using (Package leftPackage = Package.Open(left, FileMode.Open, FileAccess.Read)) - using (Package rightPackage = Package.Open(right, FileMode.Open, FileAccess.Read)) - { - return PackageHelper.Compare(leftPackage, rightPackage, false, ExcludeMethod, out message); - } + using var leftPackage = Package.Open(left, FileMode.Open, FileAccess.Read); + using var rightPackage = Package.Open(right, FileMode.Open, FileAccess.Read); + return PackageHelper.Compare(leftPackage, rightPackage, false, ExcludeMethod, out message, ignoreColumnFormat); } + //Exclude service data private static bool ExcludeMethod(Uri uri) { - //Exclude service data - if (uri.OriginalString.EndsWith(".rels") || - uri.OriginalString.EndsWith(".psmdcp")) - { - return true; - } - return false; + return uri.OriginalString.EndsWith(".rels") || uri.OriginalString.EndsWith(".psmdcp") || uri.OriginalString.EndsWith("app.xml"); } } } diff --git a/ClosedXML.Tests/Utils/PackageHelper.cs b/ClosedXML.Tests/Utils/PackageHelper.cs index 0eed740a8..91fc7efbb 100644 --- a/ClosedXML.Tests/Utils/PackageHelper.cs +++ b/ClosedXML.Tests/Utils/PackageHelper.cs @@ -8,7 +8,7 @@ using System.Text; using System.Xml.Serialization; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Utils { public static class PackageHelper { @@ -18,11 +18,9 @@ public static void WriteXmlPart(Package package, Uri uri, object content, XmlSer { package.DeletePart(uri); } - PackagePart part = package.CreatePart(uri, MediaTypeNames.Text.Xml, CompressionOption.Fast); - using (Stream stream = part.GetStream()) - { - serializer.Serialize(stream, content); - } + var part = package.CreatePart(uri, MediaTypeNames.Text.Xml, CompressionOption.Fast); + using var stream = part.GetStream(); + serializer.Serialize(stream, content); } public static object ReadXmlPart(Package package, Uri uri, XmlSerializer serializer) @@ -31,11 +29,9 @@ public static object ReadXmlPart(Package package, Uri uri, XmlSerializer seriali { throw new ApplicationException(string.Format("Package part '{0}' doesn't exists!", uri.OriginalString)); } - PackagePart part = package.GetPart(uri); - using (Stream stream = part.GetStream()) - { - return serializer.Deserialize(stream); - } + var part = package.GetPart(uri); + using var stream = part.GetStream(); + return serializer.Deserialize(stream); } public static void WriteBinaryPart(Package package, Uri uri, Stream content) @@ -44,11 +40,9 @@ public static void WriteBinaryPart(Package package, Uri uri, Stream content) { package.DeletePart(uri); } - PackagePart part = package.CreatePart(uri, MediaTypeNames.Application.Octet, CompressionOption.Fast); - using (Stream stream = part.GetStream()) - { - StreamHelper.StreamToStreamAppend(content, stream); - } + var part = package.CreatePart(uri, MediaTypeNames.Application.Octet, CompressionOption.Fast); + using var stream = part.GetStream(); + StreamHelper.StreamToStreamAppend(content, stream); } /// @@ -63,7 +57,7 @@ public static Stream ReadBinaryPart(Package package, Uri uri) { throw new ApplicationException("Package part doesn't exists!"); } - PackagePart part = package.GetPart(uri); + var part = package.GetPart(uri); return part.GetStream(); } @@ -76,15 +70,15 @@ public static void CopyPart(Uri uri, Package source, Package dest, bool overwrit { #region Check - if (ReferenceEquals(uri, null)) + if (uri is null) { throw new ArgumentNullException("uri"); } - if (ReferenceEquals(source, null)) + if (source is null) { throw new ArgumentNullException("source"); } - if (ReferenceEquals(dest, null)) + if (dest is null) { throw new ArgumentNullException("dest"); } @@ -100,16 +94,12 @@ public static void CopyPart(Uri uri, Package source, Package dest, bool overwrit dest.DeletePart(uri); } - PackagePart sourcePart = source.GetPart(uri); - PackagePart destPart = dest.CreatePart(uri, sourcePart.ContentType, sourcePart.CompressionOption); + var sourcePart = source.GetPart(uri); + var destPart = dest.CreatePart(uri, sourcePart.ContentType, sourcePart.CompressionOption); - using (Stream sourceStream = sourcePart.GetStream()) - { - using (Stream destStream = destPart.GetStream()) - { - StreamHelper.StreamToStreamAppend(sourceStream, destStream); - } - } + using var sourceStream = sourcePart.GetStream(); + using var destStream = destPart.GetStream(); + StreamHelper.StreamToStreamAppend(sourceStream, destStream); } public static void WritePart(Package package, PackagePartDescriptor descriptor, T content, @@ -117,15 +107,15 @@ public static void WritePart(Package package, PackagePartDescriptor descripto { #region Check - if (ReferenceEquals(package, null)) + if (package is null) { throw new ArgumentNullException("package"); } - if (ReferenceEquals(descriptor, null)) + if (descriptor is null) { throw new ArgumentNullException("descriptor"); } - if (ReferenceEquals(serializeAction, null)) + if (serializeAction is null) { throw new ArgumentNullException("serializeAction"); } @@ -136,26 +126,24 @@ public static void WritePart(Package package, PackagePartDescriptor descripto { package.DeletePart(descriptor.Uri); } - PackagePart part = package.CreatePart(descriptor.Uri, descriptor.ContentType, descriptor.CompressOption); - using (Stream stream = part.GetStream()) - { - serializeAction(stream, content); - } + var part = package.CreatePart(descriptor.Uri, descriptor.ContentType, descriptor.CompressOption); + using var stream = part.GetStream(); + serializeAction(stream, content); } public static void WritePart(Package package, PackagePartDescriptor descriptor, Action serializeAction) { #region Check - if (ReferenceEquals(package, null)) + if (package is null) { throw new ArgumentNullException("package"); } - if (ReferenceEquals(descriptor, null)) + if (descriptor is null) { throw new ArgumentNullException("descriptor"); } - if (ReferenceEquals(serializeAction, null)) + if (serializeAction is null) { throw new ArgumentNullException("serializeAction"); } @@ -166,26 +154,24 @@ public static void WritePart(Package package, PackagePartDescriptor descriptor, { package.DeletePart(descriptor.Uri); } - PackagePart part = package.CreatePart(descriptor.Uri, descriptor.ContentType, descriptor.CompressOption); - using (Stream stream = part.GetStream()) - { - serializeAction(stream); - } + var part = package.CreatePart(descriptor.Uri, descriptor.ContentType, descriptor.CompressOption); + using var stream = part.GetStream(); + serializeAction(stream); } public static T ReadPart(Package package, Uri uri, Func deserializeFunc) { #region Check - if (ReferenceEquals(package, null)) + if (package is null) { throw new ArgumentNullException("package"); } - if (ReferenceEquals(uri, null)) + if (uri is null) { throw new ArgumentNullException("uri"); } - if (ReferenceEquals(deserializeFunc, null)) + if (deserializeFunc is null) { throw new ArgumentNullException("deserializeFunc"); } @@ -196,26 +182,24 @@ public static T ReadPart(Package package, Uri uri, Func deserializ { throw new ApplicationException(string.Format("Package part '{0}' doesn't exists!", uri.OriginalString)); } - PackagePart part = package.GetPart(uri); - using (Stream stream = part.GetStream()) - { - return deserializeFunc(stream); - } + var part = package.GetPart(uri); + using var stream = part.GetStream(); + return deserializeFunc(stream); } public static void ReadPart(Package package, Uri uri, Action deserializeAction) { #region Check - if (ReferenceEquals(package, null)) + if (package is null) { throw new ArgumentNullException("package"); } - if (ReferenceEquals(uri, null)) + if (uri is null) { throw new ArgumentNullException("uri"); } - if (ReferenceEquals(deserializeAction, null)) + if (deserializeAction is null) { throw new ArgumentNullException("deserializeAction"); } @@ -226,26 +210,24 @@ public static void ReadPart(Package package, Uri uri, Action deserialize { throw new ApplicationException(string.Format("Package part '{0}' doesn't exists!", uri.OriginalString)); } - PackagePart part = package.GetPart(uri); - using (Stream stream = part.GetStream()) - { - deserializeAction(stream); - } + var part = package.GetPart(uri); + using var stream = part.GetStream(); + deserializeAction(stream); } public static bool TryReadPart(Package package, Uri uri, Action deserializeAction) { #region Check - if (ReferenceEquals(package, null)) + if (package is null) { throw new ArgumentNullException("package"); } - if (ReferenceEquals(uri, null)) + if (uri is null) { throw new ArgumentNullException("uri"); } - if (ReferenceEquals(deserializeAction, null)) + if (deserializeAction is null) { throw new ArgumentNullException("deserializeAction"); } @@ -256,8 +238,8 @@ public static bool TryReadPart(Package package, Uri uri, Action deserial { return false; } - PackagePart part = package.GetPart(uri); - using (Stream stream = part.GetStream()) + var part = package.GetPart(uri); + using (var stream = part.GetStream()) { deserializeAction(stream); } @@ -275,7 +257,7 @@ public static bool TryReadPart(Package package, Uri uri, Action deserial /// public static bool Compare(Package left, Package right, bool compareToFirstDifference, out string message) { - return Compare(left, right, compareToFirstDifference, null, out message); + return Compare(left, right, compareToFirstDifference, null, out message, false); } /// @@ -288,7 +270,7 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe /// /// public static bool Compare(Package left, Package right, bool compareToFirstDifference, - Func excludeMethod, out string message) + Func excludeMethod, out string message, bool ignoreColumnFormat) { #region Check @@ -304,11 +286,11 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe #endregion Check excludeMethod = excludeMethod ?? (uri => false); - PackagePartCollection leftParts = left.GetParts(); - PackagePartCollection rightParts = right.GetParts(); + var leftParts = left.GetParts(); + var rightParts = right.GetParts(); var pairs = new Dictionary(); - foreach (PackagePart part in leftParts) + foreach (var part in leftParts) { if (excludeMethod(part.Uri)) { @@ -316,13 +298,13 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe } pairs.Add(part.Uri, new PartPair(part.Uri, CompareStatus.OnlyOnLeft)); } - foreach (PackagePart part in rightParts) + foreach (var part in rightParts) { if (excludeMethod(part.Uri)) { continue; } - if (pairs.TryGetValue(part.Uri, out PartPair pair)) + if (pairs.TryGetValue(part.Uri, out var pair)) { pair.Status = CompareStatus.Equal; } @@ -334,10 +316,10 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe if (compareToFirstDifference && pairs.Any(pair => pair.Value.Status != CompareStatus.Equal)) { - goto EXIT; + return AgregateCompareResult(out message, pairs); } - foreach (PartPair pair in pairs.Values) + foreach (var pair in pairs.Values) { if (pair.Status != CompareStatus.Equal) { @@ -345,40 +327,37 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe } var leftPart = left.GetPart(pair.Uri); var rightPart = right.GetPart(pair.Uri); - using (Stream leftPackagePartStream = leftPart.GetStream(FileMode.Open, FileAccess.Read)) - using (Stream rightPackagePartStream = rightPart.GetStream(FileMode.Open, FileAccess.Read)) - using (var leftMemoryStream = new MemoryStream()) - using (var rightMemoryStream = new MemoryStream()) - { - leftPackagePartStream.CopyTo(leftMemoryStream); - rightPackagePartStream.CopyTo(rightMemoryStream); + using var leftPackagePartStream = leftPart.GetStream(FileMode.Open, FileAccess.Read); + using var rightPackagePartStream = rightPart.GetStream(FileMode.Open, FileAccess.Read); + using var leftMemoryStream = new MemoryStream(); + using var rightMemoryStream = new MemoryStream(); + leftPackagePartStream.CopyTo(leftMemoryStream); + rightPackagePartStream.CopyTo(rightMemoryStream); - leftMemoryStream.Seek(0, SeekOrigin.Begin); - rightMemoryStream.Seek(0, SeekOrigin.Begin); + leftMemoryStream.Seek(0, SeekOrigin.Begin); + rightMemoryStream.Seek(0, SeekOrigin.Begin); - bool stripColumnWidthsFromSheet = TestHelper.StripColumnWidths && - leftPart.ContentType == @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" && - rightPart.ContentType == @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"; + var stripColumnWidthsFromSheet = ignoreColumnFormat && + leftPart.ContentType == @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" && + rightPart.ContentType == @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"; - var tuple1 = new Tuple(pair.Uri, leftMemoryStream); - var tuple2 = new Tuple(pair.Uri, rightMemoryStream); + var tuple1 = new Tuple(pair.Uri, leftMemoryStream); + var tuple2 = new Tuple(pair.Uri, rightMemoryStream); - if (!StreamHelper.Compare(tuple1, tuple2, stripColumnWidthsFromSheet)) + if (!StreamHelper.Compare(tuple1, tuple2, stripColumnWidthsFromSheet)) + { + pair.Status = CompareStatus.NonEqual; + if (compareToFirstDifference) { - pair.Status = CompareStatus.NonEqual; - if (compareToFirstDifference) - { - goto EXIT; - } + return AgregateCompareResult(out message, pairs); } } } - EXIT: - List sortedPairs = pairs.Values.ToList(); + var sortedPairs = pairs.Values.ToList(); sortedPairs.Sort((one, other) => one.Uri.OriginalString.CompareTo(other.Uri.OriginalString)); var sbuilder = new StringBuilder(); - foreach (PartPair pair in sortedPairs) + foreach (var pair in sortedPairs) { if (pair.Status == CompareStatus.Equal) { @@ -391,12 +370,26 @@ public static bool Compare(Package left, Package right, bool compareToFirstDiffe return message.Length == 0; } - #region Nested type: PackagePartDescriptor + private static bool AgregateCompareResult(out string message, Dictionary pairs) + { + var sortedPairs = pairs.Values.ToList(); + sortedPairs.Sort((one, other) => one.Uri.OriginalString.CompareTo(other.Uri.OriginalString)); + var sbuilder = new StringBuilder(); + foreach (var pair in sortedPairs) + { + if (pair.Status == CompareStatus.Equal) + { + continue; + } + sbuilder.AppendFormat("{0} :{1}", pair.Uri, pair.Status); + sbuilder.AppendLine(); + } + message = sbuilder.ToString(); + return message.Length == 0; + } public sealed class PackagePartDescriptor { - #region Private fields - [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly CompressionOption _compressOption; @@ -406,10 +399,6 @@ public sealed class PackagePartDescriptor [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly Uri _uri; - #endregion Private fields - - #region Constructor - /// /// Instance constructor /// @@ -418,9 +407,7 @@ public sealed class PackagePartDescriptor /// public PackagePartDescriptor(Uri uri, string contentType, CompressionOption compressOption) { - #region Check - - if (ReferenceEquals(uri, null)) + if (uri is null) { throw new ArgumentNullException("uri"); } @@ -429,17 +416,11 @@ public PackagePartDescriptor(Uri uri, string contentType, CompressionOption comp throw new ArgumentNullException("contentType"); } - #endregion Check - _uri = uri; _contentType = contentType; _compressOption = compressOption; } - #endregion Constructor - - #region Public properties - public Uri Uri { [DebuggerStepThrough] @@ -458,20 +439,12 @@ public CompressionOption CompressOption get { return _compressOption; } } - #endregion Public properties - - #region Public methods - public override string ToString() { return string.Format("Uri:{0} ContentType: {1}, Compression: {2}", _uri, _contentType, _compressOption); } - - #endregion Public methods } - #endregion Nested type: PackagePartDescriptor - #region Nested type: CompareStatus private enum CompareStatus @@ -484,32 +457,20 @@ private enum CompareStatus #endregion Nested type: CompareStatus - #region Nested type: PartPair - private sealed class PartPair { - #region Private fields - [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly Uri _uri; [DebuggerBrowsable(DebuggerBrowsableState.Never)] private CompareStatus _status; - #endregion Private fields - - #region Constructor - public PartPair(Uri uri, CompareStatus status) { _uri = uri; _status = status; } - #endregion Constructor - - #region Public properties - public Uri Uri { [DebuggerStepThrough] @@ -523,12 +484,8 @@ public CompareStatus Status [DebuggerStepThrough] set { _status = value; } } - - #endregion Public properties } - #endregion Nested type: PartPair - //-- } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Utils/PivotTableComparer.cs b/ClosedXML.Tests/Utils/PivotTableComparer.cs index b2347f59a..48dc8e4f2 100644 --- a/ClosedXML.Tests/Utils/PivotTableComparer.cs +++ b/ClosedXML.Tests/Utils/PivotTableComparer.cs @@ -3,7 +3,7 @@ using System.Collections.Generic; using System.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Utils { internal class PivotTableComparer : IEqualityComparer { @@ -17,16 +17,22 @@ public PivotTableComparer() public PivotTableComparer(bool compareName, bool compareRelId, bool compareTargetCellAddress) { - this._compareName = compareName; - this._compareRelId = compareRelId; - this._compareTargetCellAddress = compareTargetCellAddress; + _compareName = compareName; + _compareRelId = compareRelId; + _compareTargetCellAddress = compareTargetCellAddress; } public bool Equals(XLPivotTable x, XLPivotTable y) { - if (x == null && y == null) return true; + if (x == null && y == null) + { + return true; + } - if (x == null || y == null) return false; + if (x == null || y == null) + { + return false; + } return (!_compareName || StringComparer.CurrentCulture.Equals(x.Name, y.Name)) @@ -41,6 +47,8 @@ public bool Equals(XLPivotTable x, XLPivotTable y) && StringComparer.CurrentCulture.Equals(x.Title, y.Title) && StringComparer.CurrentCulture.Equals(x.Description, y.Description) + && StringComparer.CurrentCulture.Equals(x.GrandTotalCaption, y.GrandTotalCaption) + && StringComparer.CurrentCulture.Equals(x.DataCaption, y.DataCaption) && StringComparer.CurrentCulture.Equals(x.ColumnHeaderCaption, y.ColumnHeaderCaption) && StringComparer.CurrentCulture.Equals(x.RowHeaderCaption, y.RowHeaderCaption) && x.MergeAndCenterWithLabels.Equals(y.MergeAndCenterWithLabels) diff --git a/ClosedXML.Tests/Utils/ResourceFileExtractor.cs b/ClosedXML.Tests/Utils/ResourceFileExtractor.cs index 9612652a9..5e9a5ad33 100644 --- a/ClosedXML.Tests/Utils/ResourceFileExtractor.cs +++ b/ClosedXML.Tests/Utils/ResourceFileExtractor.cs @@ -4,7 +4,7 @@ using System.IO; using System.Reflection; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Utils { /// /// Summary description for ResourceFileExtractor. @@ -26,9 +26,9 @@ public static ResourceFileExtractor Instance { get { - Assembly _assembly = Assembly.GetCallingAssembly(); - string _key = _assembly.GetName().FullName; - if (!extractors.TryGetValue(_key, out ResourceFileExtractor extractor) + var _assembly = Assembly.GetCallingAssembly(); + var _key = _assembly.GetName().FullName; + if (!extractors.TryGetValue(_key, out var extractor) && !extractors.TryGetValue(_key, out extractor)) { extractor = new ResourceFileExtractor(_assembly, true, null); @@ -45,12 +45,8 @@ public static ResourceFileExtractor Instance #region Private fields - private readonly Assembly m_assembly; private readonly ResourceFileExtractor m_baseExtractor; - private bool m_isStatic; - //private string ResourceFilePath { get; } - #endregion Private fields #region Constructors @@ -164,12 +160,12 @@ private ResourceFileExtractor(Assembly assembly, bool isStatic, ResourceFileExtr public bool IsStatic { get; set; } - public IEnumerable GetFileNames(Func predicate = null) + public IEnumerable GetFileNames(Func predicate = null) { predicate = predicate ?? (s => true); - string _path = AssemblyName + ResourceFilePath; - foreach (string _resourceName in Assembly.GetManifestResourceNames()) + var _path = AssemblyName + ResourceFilePath; + foreach (var _resourceName in Assembly.GetManifestResourceNames()) { if (_resourceName.StartsWith(_path) && predicate(_resourceName)) { @@ -184,9 +180,9 @@ public IEnumerable GetFileNames(Func predicate = null) public string ReadFileFromResource(string fileName) { - Stream _stream = ReadFileFromResourceToStream(fileName); + var _stream = ReadFileFromResourceToStream(fileName); string _result; - StreamReader sr = new StreamReader(_stream); + var sr = new StreamReader(_stream); try { _result = sr.ReadToEnd(); @@ -211,7 +207,7 @@ public string ReadFileFromResourceFormat(string fileName, params object[] format /// public string ReadSpecificFileFromResource(string specificPath, string fileName) { - ResourceFileExtractor _ext = new ResourceFileExtractor(Assembly, specificPath); + var _ext = new ResourceFileExtractor(Assembly, specificPath); return _ext.ReadFileFromResource(fileName); } @@ -223,8 +219,8 @@ public string ReadSpecificFileFromResource(string specificPath, string fileName) /// ApplicationException. public Stream ReadFileFromResourceToStream(string fileName) { - string _nameResFile = AssemblyName + ResourceFilePath + fileName; - Stream _stream = Assembly.GetManifestResourceStream(_nameResFile); + var _nameResFile = AssemblyName + ResourceFilePath + fileName; + var _stream = Assembly.GetManifestResourceStream(_nameResFile); #region Not found diff --git a/ClosedXML.Tests/Utils/StreamHelper.cs b/ClosedXML.Tests/Utils/StreamHelper.cs index e5f4f0512..a2e3a8289 100644 --- a/ClosedXML.Tests/Utils/StreamHelper.cs +++ b/ClosedXML.Tests/Utils/StreamHelper.cs @@ -1,10 +1,13 @@ using System; using System.Collections.Generic; +using System.Globalization; using System.IO; using System.Linq; using System.Text.RegularExpressions; +using System.Threading; +using System.Xml.Linq; -namespace ClosedXML.Tests +namespace ClosedXML.Tests.Utils { /// /// Help methods for work with streams @@ -18,9 +21,9 @@ public static class StreamHelper /// Byte array public static byte[] StreamToArray(Stream pStream) { - long iLength = pStream.Length; + var iLength = pStream.Length; var bytes = new byte[iLength]; - for (int i = 0; i < iLength; i++) + for (var i = 0; i < iLength; i++) { bytes[i] = (byte)pStream.ReadByte(); } @@ -36,13 +39,11 @@ public static byte[] StreamToArray(Stream pStream) /// public static Stream ArrayToStreamAppend(byte[] pBynaryArray, Stream pStream) { - #region Check params - - if (ReferenceEquals(pBynaryArray, null)) + if (pBynaryArray is null) { throw new ArgumentNullException("pBynaryArray"); } - if (ReferenceEquals(pStream, null)) + if (pStream is null) { throw new ArgumentNullException("pStream"); } @@ -51,9 +52,7 @@ public static Stream ArrayToStreamAppend(byte[] pBynaryArray, Stream pStream) throw new ArgumentException("Can't write to stream", "pStream"); } - #endregion Check params - - foreach (byte b in pBynaryArray) + foreach (var b in pBynaryArray) { pStream.WriteByte(b); } @@ -67,13 +66,11 @@ public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite) public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite, long dataLength) { - #region Check params - - if (ReferenceEquals(streamIn, null)) + if (streamIn is null) { throw new ArgumentNullException("streamIn"); } - if (ReferenceEquals(streamToWrite, null)) + if (streamToWrite is null) { throw new ArgumentNullException("streamToWrite"); } @@ -86,8 +83,6 @@ public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite, l throw new ArgumentException("Can't write to stream", "streamToWrite"); } - #endregion Check params - var buf = new byte[512]; long length; if (dataLength == 0) @@ -98,10 +93,10 @@ public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite, l { length = dataLength; } - long rest = length; + var rest = length; while (rest > 0) { - int len1 = streamIn.Read(buf, 0, rest >= 512 ? 512 : (int)rest); + var len1 = streamIn.Read(buf, 0, rest >= 512 ? 512 : (int)rest); streamToWrite.Write(buf, 0, len1); rest -= len1; } @@ -116,68 +111,112 @@ public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite, l /// public static bool Compare(Tuple tuple1, Tuple tuple2, bool stripColumnWidths) { - #region Check - if (tuple1 == null || tuple1.Item1 == null || tuple1.Item2 == null) { - throw new ArgumentNullException("one"); + throw new ArgumentNullException(nameof(tuple1)); } if (tuple2 == null || tuple2.Item1 == null || tuple2.Item2 == null) { - throw new ArgumentNullException("other"); + throw new ArgumentNullException(nameof(tuple2)); } if (tuple1.Item2.Position != 0) { - throw new ArgumentException("Must be in position 0", "one"); + throw new ArgumentException("Must be in position 0", nameof(tuple1)); } if (tuple2.Item2.Position != 0) { - throw new ArgumentException("Must be in position 0", "other"); + throw new ArgumentException("Must be in position 0", nameof(tuple2)); } - #endregion Check - - var stringOne = new StreamReader(tuple1.Item2).ReadToEnd().RemoveIgnoredParts(tuple1.Item1, stripColumnWidths, ignoreGuids: true); - var stringOther = new StreamReader(tuple2.Item2).ReadToEnd().RemoveIgnoredParts(tuple2.Item1, stripColumnWidths, ignoreGuids: true); + using var streamReader = new StreamReader(tuple1.Item2); + var stringOne = streamReader.ReadToEnd().RemoveIgnoredParts(tuple1.Item1, stripColumnWidths, ignoreGuids: true); + using var streamReaderOther = new StreamReader(tuple2.Item2); + var stringOther = streamReaderOther.ReadToEnd().RemoveIgnoredParts(tuple2.Item1, stripColumnWidths, ignoreGuids: true); return stringOne == stringOther; } - private static string RemoveIgnoredParts(this string s, Uri uri, Boolean ignoreColumnWidths, Boolean ignoreGuids) + private static string RemoveIgnoredParts(this string s, Uri uri, bool ignoreColumnFormat, bool ignoreGuids) { foreach (var pair in uriSpecificIgnores.Where(p => p.Key.Equals(uri.OriginalString))) + { s = pair.Value.Replace(s, ""); + } // Collapse empty xml elements s = emptyXmlElementRegex.Replace(s, "<$1 />"); - if (ignoreColumnWidths) - s = RemoveColumnWidths(s); + if (ignoreColumnFormat) + { + s = RemoveColumnFormatSection(s); + } if (ignoreGuids) + { s = RemoveGuids(s); + } - return s; + return RemoveNonCodingXmlFormatDiff(s); + } + + private static string RemoveNonCodingXmlFormatDiff(string s) + { + var currentUserCulture = Thread.CurrentThread.CurrentCulture; + var currentUserUiCulture = Thread.CurrentThread.CurrentUICulture; + try + { + Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US"); + Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); + + try + { + var original = XDocument.Parse(s); + + var normalized = new XDocument(original); + + return normalized.ToString(); + } + catch (System.Xml.XmlException ex) + { + if (ex.Message.Contains("Data at the root level is invalid.")) + { + return s; + } + + if (ex.Message.Contains("hexadecimal value 0x00, is an invalid character.")) + { + return s; + } + throw; + } + catch (Exception) + { + throw; + } + } + finally + { + Thread.CurrentThread.CurrentCulture = currentUserCulture; + Thread.CurrentThread.CurrentUICulture = currentUserUiCulture; + } } - private static IEnumerable> uriSpecificIgnores = new List>() + private static readonly IEnumerable> uriSpecificIgnores = new List>() { // Remove dcterms elements new KeyValuePair("/docProps/core.xml", new Regex(@"", RegexOptions.Compiled)) }; - private static Regex emptyXmlElementRegex = new Regex(@"<([\w:]+)><\/\1>", RegexOptions.Compiled); - private static Regex columnRegex = new Regex("", RegexOptions.Compiled); - private static Regex widthRegex = new Regex("width=\"\\d+(\\.\\d+)?\"\\s+", RegexOptions.Compiled); + private static readonly Regex emptyXmlElementRegex = new Regex(@"<([\w:]+)><\/\1>", RegexOptions.Compiled); + private static readonly Regex columnRegex = new Regex("()", RegexOptions.Compiled); - private static String RemoveColumnWidths(String s) + private static string RemoveColumnFormatSection(string s) { - var replacements = new Dictionary(); + var replacements = new Dictionary(); foreach (var m in columnRegex.Matches(s).OfType()) { var original = m.Groups[0].Value; - var replacement = widthRegex.Replace(original, ""); - replacements.Add(original, replacement); + replacements.Add(original, string.Empty); } foreach (var r in replacements) @@ -187,9 +226,9 @@ private static String RemoveColumnWidths(String s) return s; } - private static Regex guidRegex = new Regex(@"{[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}}", RegexOptions.Compiled | RegexOptions.Multiline); + private static readonly Regex guidRegex = new Regex(@"{[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}}", RegexOptions.Compiled | RegexOptions.Multiline); - private static String RemoveGuids(String s) + private static string RemoveGuids(string s) { return guidRegex.Replace(s, delegate (Match m) { @@ -197,4 +236,4 @@ private static String RemoveGuids(String s) }); } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/Utils/TemporaryFile.cs b/ClosedXML.Tests/Utils/TemporaryFile.cs index 4cfebcfa6..9d8d2e4a8 100644 --- a/ClosedXML.Tests/Utils/TemporaryFile.cs +++ b/ClosedXML.Tests/Utils/TemporaryFile.cs @@ -5,6 +5,8 @@ namespace ClosedXML.Tests.Utils { internal class TemporaryFile : IDisposable { + private bool _disposed; + internal TemporaryFile() : this(System.IO.Path.ChangeExtension(System.IO.Path.GetTempFileName(), "xlsx")) { } @@ -13,10 +15,10 @@ internal TemporaryFile(string path) : this(path, false) { } - internal TemporaryFile(String path, bool preserve) + internal TemporaryFile(string path, bool preserve) { - this.Path = path; - this.Preserve = preserve; + Path = path; + Preserve = preserve; } public string Path { get; private set; } @@ -24,13 +26,30 @@ internal TemporaryFile(String path, bool preserve) public void Dispose() { - if (!Preserve) + // Dispose of unmanaged resources. + Dispose(true); + // Suppress finalization. + GC.SuppressFinalize(this); + } + + public void Dispose(bool disposing) + { + if (_disposed) + { + return; + } + + if (disposing && !Preserve) + { File.Delete(Path); + } + + _disposed = true; } public override string ToString() { - return this.Path; + return Path; } } -} +} \ No newline at end of file diff --git a/ClosedXML.Tests/XLHelperTests.cs b/ClosedXML.Tests/XLHelperTests.cs index 9af67603f..9d846bf67 100644 --- a/ClosedXML.Tests/XLHelperTests.cs +++ b/ClosedXML.Tests/XLHelperTests.cs @@ -28,84 +28,84 @@ public void IsValidColumnTest() [Test] public void ReplaceRelative1() { - string result = XLHelper.ReplaceRelative("A1", 2, "B"); + var result = XLHelper.ReplaceRelative("A1", 2, "B"); Assert.AreEqual("B2", result); } [Test] public void ReplaceRelative2() { - string result = XLHelper.ReplaceRelative("$A1", 2, "B"); + var result = XLHelper.ReplaceRelative("$A1", 2, "B"); Assert.AreEqual("$A2", result); } [Test] public void ReplaceRelative3() { - string result = XLHelper.ReplaceRelative("A$1", 2, "B"); + var result = XLHelper.ReplaceRelative("A$1", 2, "B"); Assert.AreEqual("B$1", result); } [Test] public void ReplaceRelative4() { - string result = XLHelper.ReplaceRelative("$A$1", 2, "B"); + var result = XLHelper.ReplaceRelative("$A$1", 2, "B"); Assert.AreEqual("$A$1", result); } [Test] public void ReplaceRelative5() { - string result = XLHelper.ReplaceRelative("1:1", 2, "B"); + var result = XLHelper.ReplaceRelative("1:1", 2, "B"); Assert.AreEqual("2:2", result); } [Test] public void ReplaceRelative6() { - string result = XLHelper.ReplaceRelative("$1:1", 2, "B"); + var result = XLHelper.ReplaceRelative("$1:1", 2, "B"); Assert.AreEqual("$1:2", result); } [Test] public void ReplaceRelative7() { - string result = XLHelper.ReplaceRelative("1:$1", 2, "B"); + var result = XLHelper.ReplaceRelative("1:$1", 2, "B"); Assert.AreEqual("2:$1", result); } [Test] public void ReplaceRelative8() { - string result = XLHelper.ReplaceRelative("$1:$1", 2, "B"); + var result = XLHelper.ReplaceRelative("$1:$1", 2, "B"); Assert.AreEqual("$1:$1", result); } [Test] public void ReplaceRelative9() { - string result = XLHelper.ReplaceRelative("A:A", 2, "B"); + var result = XLHelper.ReplaceRelative("A:A", 2, "B"); Assert.AreEqual("B:B", result); } [Test] public void ReplaceRelativeA() { - string result = XLHelper.ReplaceRelative("$A:A", 2, "B"); + var result = XLHelper.ReplaceRelative("$A:A", 2, "B"); Assert.AreEqual("$A:B", result); } [Test] public void ReplaceRelativeB() { - string result = XLHelper.ReplaceRelative("A:$A", 2, "B"); + var result = XLHelper.ReplaceRelative("A:$A", 2, "B"); Assert.AreEqual("B:$A", result); } [Test] public void ReplaceRelativeC() { - string result = XLHelper.ReplaceRelative("$A:$A", 2, "B"); + var result = XLHelper.ReplaceRelative("$A:$A", 2, "B"); Assert.AreEqual("$A:$A", result); } diff --git a/ClosedXML.sln b/ClosedXML.sln index 4744e949c..20258ce96 100644 --- a/ClosedXML.sln +++ b/ClosedXML.sln @@ -1,16 +1,10 @@  Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 16 -VisualStudioVersion = 16.0.30621.155 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.32126.317 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClosedXML.Sandbox", "ClosedXML.Sandbox\ClosedXML.Sandbox.csproj", "{38B882F0-E6F2-45C5-9BE9-CDC27FBEB4AB}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5C94E22C-85AA-48FD-B082-CF929FFC6C31}" - ProjectSection(SolutionItems) = preProject - appveyor.yml = appveyor.yml - ClosedXML.vsmdi = ClosedXML.vsmdi - EndProjectSection -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClosedXML.Examples", "ClosedXML.Examples\ClosedXML.Examples.csproj", "{03A518D0-1CB7-488E-861C-C4E782B27A46}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClosedXML", "ClosedXML\ClosedXML.csproj", "{BD5E6BFE-E837-4A35-BCA9-39667D873A20}" @@ -19,8 +13,17 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClosedXML.Tests", "ClosedXM EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{073CFB1C-43DC-4ADC-9D12-BB8D7B10C099}" ProjectSection(SolutionItems) = preProject + .github\dependabot.yml = .github\dependabot.yml + .github\workflows\dotnet.yml = .github\workflows\dotnet.yml .github\ISSUE_TEMPLATE.md = .github\ISSUE_TEMPLATE.md - .github\PULL_REQUEST_TEMPLATE.md = .github\PULL_REQUEST_TEMPLATE.md + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{A120216E-5210-463B-9204-09AF19400FE7}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + CONTRIBUTING.md = CONTRIBUTING.md + README.md = README.md + testenvironments.json = testenvironments.json EndProjectSection EndProject Global diff --git a/ClosedXML/Attributes/XLColumnAttribute.cs b/ClosedXML/Attributes/XLColumnAttribute.cs index 67ab26fd0..6e7461e0a 100644 --- a/ClosedXML/Attributes/XLColumnAttribute.cs +++ b/ClosedXML/Attributes/XLColumnAttribute.cs @@ -1,4 +1,3 @@ -using ClosedXML.Excel; using System; using System.Linq; using System.Reflection; @@ -8,35 +7,51 @@ namespace ClosedXML.Attributes [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)] public class XLColumnAttribute : Attribute { - public String Header { get; set; } - public Boolean Ignore { get; set; } - public Int32 Order { get; set; } + public string Header { get; set; } + public bool Ignore { get; set; } + public int Order { get; set; } private static XLColumnAttribute GetXLColumnAttribute(MemberInfo mi) { - if (!mi.HasAttribute()) return null; + if (!mi.HasAttribute()) + { + return null; + } + return mi.GetAttributes().First(); } - internal static String GetHeader(MemberInfo mi) + internal static string GetHeader(MemberInfo mi) { var attribute = GetXLColumnAttribute(mi); - if (attribute == null) return null; - return String.IsNullOrWhiteSpace(attribute.Header) ? null : attribute.Header; + if (attribute == null) + { + return null; + } + + return string.IsNullOrWhiteSpace(attribute.Header) ? null : attribute.Header; } - internal static Int32 GetOrder(MemberInfo mi) + internal static int GetOrder(MemberInfo mi) { var attribute = GetXLColumnAttribute(mi); - if (attribute == null) return Int32.MaxValue; + if (attribute == null) + { + return int.MaxValue; + } + return attribute.Order; } - internal static Boolean IgnoreMember(MemberInfo mi) + internal static bool IgnoreMember(MemberInfo mi) { var attribute = GetXLColumnAttribute(mi); - if (attribute == null) return false; + if (attribute == null) + { + return false; + } + return attribute.Ignore; } } -} +} \ No newline at end of file diff --git a/ClosedXML/ClosedXML.csproj b/ClosedXML/ClosedXML.csproj index 0024d8495..d7c56d41a 100644 --- a/ClosedXML/ClosedXML.csproj +++ b/ClosedXML/ClosedXML.csproj @@ -1,83 +1,82 @@ - - - - netstandard2.0;net40;net46 - 8.0 - ClosedXML - ClosedXML - 0.95.4 - Francois Botha, Aleksei Pankratev, Manuel de Leon, Amir Ghezelbash - Francois Botha, Aleksei Pankratev - - ClosedXML - See https://github.com/ClosedXML/ClosedXML/releases/tag/$(productVersion) - ClosedXML is a .NET library for reading, manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive and user-friendly interface to dealing with the underlying OpenXML API. - MIT - https://github.com/ClosedXML/ClosedXML - true - nuget-logo.png - https://raw.githubusercontent.com/ClosedXML/ClosedXML/develop/resources/logo/nuget-logo.png - true - $(NoWarn);NU1605;CS1591 - true - Debug;Release - MIT - true - ..\ClosedXML.snk - - - - true - true - - - - $(DefineConstants);_NETSTANDARD_;_NETSTANDARD2_0_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET40_ - - - - $(DefineConstants);_NETFRAMEWORK_;_NET46_ - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - - - - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - - - - - - - - - - - - - - - - \ No newline at end of file + + + netstandard2.0;net48 + netstandard2.0 + 8.0 + ClosedXML + DocumentPartner.ClosedXML + Francois Botha, Aleksei Pankratev, Manuel de Leon, Amir Ghezelbash, Roman Brandstetter, Stefan Seeland + Francois Botha, Aleksei Pankratev + ClosedXML + $(CURRENT_VERSION) + 0.0.1 + $(Version) + $(Version) + $(Version) + $(GITHUB_SHA) + DevBuild + $(LAST_COMMIT_MESSAGE) + ClosedXML is a .NET library for reading, manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive and user-friendly interface to dealing with the underlying OpenXML API. + MIT + Product.png + https://github.com/rubicon-oss/DocumentPartner.ClosedXML + Debug;Release + MIT + true + true + snupkg + true + true + ..\ClosedXML.snk + Product.png + true + https://github.com/rubicon-oss/DocumentPartner.ClosedXML + nugetReadme.md + true + True + true + Excel XLSX OpenXml Windows Linux MacOs + False + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + diff --git a/ClosedXML/ClosedXML.nuspec b/ClosedXML/ClosedXML.nuspec deleted file mode 100644 index f065911ef..000000000 --- a/ClosedXML/ClosedXML.nuspec +++ /dev/null @@ -1,27 +0,0 @@ - - - - $id$ - $version$ - $title$ - $author$ - $author$ - ClosedXML is a .NET library for reading, manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive and user-friendly interface to dealing with the underlying OpenXML API. - https://github.com/ClosedXML/ClosedXML/blob/master/LICENSE - https://github.com/ClosedXML/ClosedXML - false - @ClosedXML - ClosedXML - - - - - - - - - - - - - \ No newline at end of file diff --git a/ClosedXML/Excel/AutoFilters/IXLAutoFilter.cs b/ClosedXML/Excel/AutoFilters/IXLAutoFilter.cs index 8afbac971..1c8af42af 100644 --- a/ClosedXML/Excel/AutoFilters/IXLAutoFilter.cs +++ b/ClosedXML/Excel/AutoFilters/IXLAutoFilter.cs @@ -13,23 +13,23 @@ public enum XLTopBottomPart { Top, Bottom } public interface IXLAutoFilter { [Obsolete("Use IsEnabled")] - Boolean Enabled { get; set; } + bool Enabled { get; set; } IEnumerable HiddenRows { get; } - Boolean IsEnabled { get; set; } + bool IsEnabled { get; set; } IXLRange Range { get; set; } - Int32 SortColumn { get; set; } - Boolean Sorted { get; set; } + int SortColumn { get; set; } + bool Sorted { get; set; } XLSortOrder SortOrder { get; set; } IEnumerable VisibleRows { get; } IXLAutoFilter Clear(); - IXLFilterColumn Column(String column); + IXLFilterColumn Column(string column); - IXLFilterColumn Column(Int32 column); + IXLFilterColumn Column(int column); IXLAutoFilter Reapply(); - IXLAutoFilter Sort(Int32 columnToSortBy = 1, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLAutoFilter Sort(int columnToSortBy = 1, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); } } diff --git a/ClosedXML/Excel/AutoFilters/IXLCustomFilteredColumn.cs b/ClosedXML/Excel/AutoFilters/IXLCustomFilteredColumn.cs index 37c6a1726..b16919f32 100644 --- a/ClosedXML/Excel/AutoFilters/IXLCustomFilteredColumn.cs +++ b/ClosedXML/Excel/AutoFilters/IXLCustomFilteredColumn.cs @@ -9,11 +9,11 @@ public interface IXLCustomFilteredColumn void LessThan(T value) where T : IComparable; void EqualOrGreaterThan(T value) where T : IComparable; void EqualOrLessThan(T value) where T : IComparable; - void BeginsWith(String value); - void NotBeginsWith(String value); - void EndsWith(String value); - void NotEndsWith(String value); - void Contains(String value); - void NotContains(String value); + void BeginsWith(string value); + void NotBeginsWith(string value); + void EndsWith(string value); + void NotEndsWith(string value); + void Contains(string value); + void NotContains(string value); } } \ No newline at end of file diff --git a/ClosedXML/Excel/AutoFilters/IXLFilterColumn.cs b/ClosedXML/Excel/AutoFilters/IXLFilterColumn.cs index 106f48560..b9a3e064f 100644 --- a/ClosedXML/Excel/AutoFilters/IXLFilterColumn.cs +++ b/ClosedXML/Excel/AutoFilters/IXLFilterColumn.cs @@ -14,9 +14,9 @@ public interface IXLFilterColumn IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTimeGrouping dateTimeGrouping); - void Top(Int32 value, XLTopBottomType type = XLTopBottomType.Items); + void Top(int value, XLTopBottomType type = XLTopBottomType.Items); - void Bottom(Int32 value, XLTopBottomType type = XLTopBottomType.Items); + void Bottom(int value, XLTopBottomType type = XLTopBottomType.Items); void AboveAverage(); @@ -38,28 +38,28 @@ public interface IXLFilterColumn void NotBetween(T minValue, T maxValue) where T : IComparable; - IXLFilterConnector BeginsWith(String value); + IXLFilterConnector BeginsWith(string value); - IXLFilterConnector NotBeginsWith(String value); + IXLFilterConnector NotBeginsWith(string value); - IXLFilterConnector EndsWith(String value); + IXLFilterConnector EndsWith(string value); - IXLFilterConnector NotEndsWith(String value); + IXLFilterConnector NotEndsWith(string value); - IXLFilterConnector Contains(String value); + IXLFilterConnector Contains(string value); - IXLFilterConnector NotContains(String value); + IXLFilterConnector NotContains(string value); XLFilterType FilterType { get; set; } - Int32 TopBottomValue { get; set; } + int TopBottomValue { get; set; } XLTopBottomType TopBottomType { get; set; } XLTopBottomPart TopBottomPart { get; set; } XLFilterDynamicType DynamicType { get; set; } - Double DynamicValue { get; set; } + double DynamicValue { get; set; } IXLFilterColumn SetFilterType(XLFilterType value); - IXLFilterColumn SetTopBottomValue(Int32 value); + IXLFilterColumn SetTopBottomValue(int value); IXLFilterColumn SetTopBottomType(XLTopBottomType value); @@ -67,6 +67,6 @@ public interface IXLFilterColumn IXLFilterColumn SetDynamicType(XLFilterDynamicType value); - IXLFilterColumn SetDynamicValue(Double value); + IXLFilterColumn SetDynamicValue(double value); } } diff --git a/ClosedXML/Excel/AutoFilters/IXLFilterConnector.cs b/ClosedXML/Excel/AutoFilters/IXLFilterConnector.cs index d5d52be4d..5c9eb5792 100644 --- a/ClosedXML/Excel/AutoFilters/IXLFilterConnector.cs +++ b/ClosedXML/Excel/AutoFilters/IXLFilterConnector.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public interface IXLFilterConnector diff --git a/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs b/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs index 35a51cfad..62da98288 100644 --- a/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs +++ b/ClosedXML/Excel/AutoFilters/XLAutoFilter.cs @@ -1,54 +1,57 @@ // Keep this file CodeMaid organised and cleaned using System; using System.Linq; +using System.Collections.Generic; namespace ClosedXML.Excel { - using System.Collections.Generic; - internal class XLAutoFilter : IXLAutoFilter { - private readonly Dictionary _columns = new Dictionary(); + private readonly Dictionary _columns = new Dictionary(); public XLAutoFilter() { Filters = new Dictionary>(); } - public Dictionary> Filters { get; private set; } + public Dictionary> Filters { get; private set; } #region IXLAutoFilter Members [Obsolete("Use IsEnabled")] - public Boolean Enabled { get => IsEnabled; set => IsEnabled = value; } - public IEnumerable HiddenRows { get => Range.Rows(r => r.WorksheetRow().IsHidden); } - public Boolean IsEnabled { get; set; } + public bool Enabled { get => IsEnabled; set => IsEnabled = value; } + public IEnumerable HiddenRows => Range.Rows(r => r.WorksheetRow().IsHidden); + public bool IsEnabled { get; set; } public IXLRange Range { get; set; } - public Int32 SortColumn { get; set; } - public Boolean Sorted { get; set; } + public int SortColumn { get; set; } + public bool Sorted { get; set; } public XLSortOrder SortOrder { get; set; } - public IEnumerable VisibleRows { get => Range.Rows(r => !r.WorksheetRow().IsHidden); } + public IEnumerable VisibleRows => Range.Rows(r => !r.WorksheetRow().IsHidden); IXLAutoFilter IXLAutoFilter.Clear() { return Clear(); } - public IXLFilterColumn Column(String column) + public IXLFilterColumn Column(string column) { var columnNumber = XLHelper.GetColumnNumberFromLetter(column); if (columnNumber < 1 || columnNumber > XLHelper.MaxColumnNumber) + { throw new ArgumentOutOfRangeException(nameof(column), "Column '" + column + "' is outside the allowed column range."); + } return Column(columnNumber); } - public IXLFilterColumn Column(Int32 column) + public IXLFilterColumn Column(int column) { if (column < 1 || column > XLHelper.MaxColumnNumber) + { throw new ArgumentOutOfRangeException(nameof(column), "Column " + column + " is outside the allowed column range."); + } - if (!_columns.TryGetValue(column, out XLFilterColumn filterColumn)) + if (!_columns.TryGetValue(column, out var filterColumn)) { filterColumn = new XLFilterColumn(this, column); _columns.Add(column, filterColumn); @@ -68,7 +71,7 @@ public IXLAutoFilter Reapply() row.WorksheetRow().Unhide() ); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { var rowMatch = true; @@ -87,46 +90,64 @@ public IXLAutoFilter Reapply() foreach (var filter in columnFilters) { var condition = filter.Condition; - var isText = filter.Value is String; + var isText = filter.Value is string; var isDateTime = filter.Value is DateTime; - Boolean filterMatch; + bool filterMatch; if (isText) + { filterMatch = condition(row.Cell(columnIndex).GetFormattedString()); + } else if (isDateTime) + { filterMatch = row.Cell(columnIndex).DataType == XLDataType.DateTime && condition(row.Cell(columnIndex).GetDateTime()); + } else + { filterMatch = row.Cell(columnIndex).DataType == XLDataType.Number && condition(row.Cell(columnIndex).GetDouble()); + } if (filter.Connector == XLConnector.And) { columnFilterMatch &= filterMatch; - if (!columnFilterMatch) break; + if (!columnFilterMatch) + { + break; + } } else { columnFilterMatch |= filterMatch; - if (columnFilterMatch) break; + if (columnFilterMatch) + { + break; + } } } rowMatch &= columnFilterMatch; - if (!rowMatch) break; + if (!rowMatch) + { + break; + } } - if (!rowMatch) row.WorksheetRow().Hide(); + if (!rowMatch) + { + row.WorksheetRow().Hide(); + } } ws.ResumeEvents(); return this; } - IXLAutoFilter IXLAutoFilter.Sort(Int32 columnToSortBy, XLSortOrder sortOrder, Boolean matchCase, - Boolean ignoreBlanks) + IXLAutoFilter IXLAutoFilter.Sort(int columnToSortBy, XLSortOrder sortOrder, bool matchCase, + bool ignoreBlanks) { return Sort(columnToSortBy, sortOrder, matchCase, ignoreBlanks); } @@ -135,12 +156,18 @@ IXLAutoFilter IXLAutoFilter.Sort(Int32 columnToSortBy, XLSortOrder sortOrder, Bo public XLAutoFilter Clear() { - if (!IsEnabled) return this; + if (!IsEnabled) + { + return this; + } IsEnabled = false; Filters.Clear(); - foreach (IXLRangeRow row in Range.Rows().Where(r => r.RowNumber() > 1)) + foreach (var row in Range.Rows().Where(r => r.RowNumber() > 1)) + { row.WorksheetRow().Unhide(); + } + return this; } @@ -148,17 +175,21 @@ public XLAutoFilter Set(IXLRangeBase range) { var firstOverlappingTable = range.Worksheet.Tables.FirstOrDefault(t => t.RangeUsed().Intersects(range)); if (firstOverlappingTable != null) + { throw new InvalidOperationException($"The range {range.RangeAddress.ToStringRelative(includeSheet: true)} is already part of table '{firstOverlappingTable.Name}'"); + } Range = range.AsRange(); IsEnabled = true; return this; } - public XLAutoFilter Sort(Int32 columnToSortBy, XLSortOrder sortOrder, Boolean matchCase, Boolean ignoreBlanks) + public XLAutoFilter Sort(int columnToSortBy, XLSortOrder sortOrder, bool matchCase, bool ignoreBlanks) { if (!IsEnabled) + { throw new InvalidOperationException("Filter has not been enabled."); + } var ws = Range.Worksheet as XLWorksheet; ws.SuspendEvents(); diff --git a/ClosedXML/Excel/AutoFilters/XLCustomFilteredColumn.cs b/ClosedXML/Excel/AutoFilters/XLCustomFilteredColumn.cs index 4c6bd52b4..19699318b 100644 --- a/ClosedXML/Excel/AutoFilters/XLCustomFilteredColumn.cs +++ b/ClosedXML/Excel/AutoFilters/XLCustomFilteredColumn.cs @@ -1,15 +1,14 @@ using System; -using System.Linq; namespace ClosedXML.Excel { internal class XLCustomFilteredColumn : IXLCustomFilteredColumn { private readonly XLAutoFilter _autoFilter; - private readonly Int32 _column; + private readonly int _column; private readonly XLConnector _connector; - public XLCustomFilteredColumn(XLAutoFilter autoFilter, Int32 column, XLConnector connector) + public XLCustomFilteredColumn(XLAutoFilter autoFilter, int column, XLConnector connector) { _autoFilter = autoFilter; _column = column; @@ -20,7 +19,7 @@ public XLCustomFilteredColumn(XLAutoFilter autoFilter, Int32 column, XLConnector public void EqualTo(T value) where T: IComparable { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { ApplyCustomFilter(value, XLFilterOperator.Equal, v => @@ -35,7 +34,7 @@ public void EqualTo(T value) where T: IComparable public void NotEqualTo(T value) where T: IComparable { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { ApplyCustomFilter(value, XLFilterOperator.NotEqual, v => @@ -71,38 +70,38 @@ public void EqualOrLessThan(T value) where T: IComparable v => v.CastTo().CompareTo(value) <= 0); } - public void BeginsWith(String value) + public void BeginsWith(string value) { ApplyCustomFilter(value + "*", XLFilterOperator.Equal, s => ((string)s).StartsWith(value, StringComparison.InvariantCultureIgnoreCase)); } - public void NotBeginsWith(String value) + public void NotBeginsWith(string value) { ApplyCustomFilter(value + "*", XLFilterOperator.NotEqual, s => !((string)s).StartsWith(value, StringComparison.InvariantCultureIgnoreCase)); } - public void EndsWith(String value) + public void EndsWith(string value) { ApplyCustomFilter("*" + value, XLFilterOperator.Equal, s => ((string)s).EndsWith(value, StringComparison.InvariantCultureIgnoreCase)); } - public void NotEndsWith(String value) + public void NotEndsWith(string value) { ApplyCustomFilter("*" + value, XLFilterOperator.NotEqual, s => !((string)s).EndsWith(value, StringComparison.InvariantCultureIgnoreCase)); } - public void Contains(String value) + public void Contains(string value) { ApplyCustomFilter("*" + value + "*", XLFilterOperator.Equal, s => ((string)s).ToLower().Contains(value.ToLower())); } - public void NotContains(String value) + public void NotContains(string value) { ApplyCustomFilter("*" + value + "*", XLFilterOperator.Equal, s => !((string)s).ToLower().Contains(value.ToLower())); @@ -110,7 +109,7 @@ public void NotContains(String value) #endregion - private void ApplyCustomFilter(T value, XLFilterOperator op, Func condition) + private void ApplyCustomFilter(T value, XLFilterOperator op, Func condition) where T : IComparable { _autoFilter.Filters[_column].Add(new XLFilter @@ -121,20 +120,26 @@ private void ApplyCustomFilter(T value, XLFilterOperator op, Func())) + { row.WorksheetRow().Unhide(); + } else + { row.WorksheetRow().Hide(); + } } } else if (condition(row.Cell(_column).GetValue())) + { row.WorksheetRow().Unhide(); + } } } } diff --git a/ClosedXML/Excel/AutoFilters/XLDateTimeGroupFilteredColumn.cs b/ClosedXML/Excel/AutoFilters/XLDateTimeGroupFilteredColumn.cs index 981532a59..7115f8bfc 100644 --- a/ClosedXML/Excel/AutoFilters/XLDateTimeGroupFilteredColumn.cs +++ b/ClosedXML/Excel/AutoFilters/XLDateTimeGroupFilteredColumn.cs @@ -10,9 +10,9 @@ public interface IXLDateTimeGroupFilteredColumn internal class XLDateTimeGroupFilteredColumn : IXLDateTimeGroupFilteredColumn { private readonly XLAutoFilter _autoFilter; - private readonly Int32 _column; + private readonly int _column; - public XLDateTimeGroupFilteredColumn(XLAutoFilter autoFilter, Int32 column) + public XLDateTimeGroupFilteredColumn(XLAutoFilter autoFilter, int column) { _autoFilter = autoFilter; _column = column; @@ -20,7 +20,7 @@ public XLDateTimeGroupFilteredColumn(XLAutoFilter autoFilter, Int32 column) public IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTimeGrouping dateTimeGrouping) { - Func condition = date2 => IsMatch(date, (DateTime) date2, dateTimeGrouping); + bool condition(object date2) => IsMatch(date, (DateTime)date2, dateTimeGrouping); _autoFilter.Filters[_column].Add(new XLFilter { @@ -32,26 +32,51 @@ public IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTi }); var rows = _autoFilter.Range.Rows(2, _autoFilter.Range.RowCount()); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { if (row.Cell(_column).DataType == XLDataType.DateTime && condition(row.Cell(_column).GetDateTime())) + { row.WorksheetRow().Unhide(); + } } return this; } - internal static Boolean IsMatch(DateTime date1, DateTime date2, XLDateTimeGrouping dateTimeGrouping) + internal static bool IsMatch(DateTime date1, DateTime date2, XLDateTimeGrouping dateTimeGrouping) { - Boolean isMatch = true; - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Year) isMatch &= date1.Year.Equals(date2.Year); - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Month) isMatch &= date1.Month.Equals(date2.Month); - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Day) isMatch &= date1.Day.Equals(date2.Day); - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Hour) isMatch &= date1.Hour.Equals(date2.Hour); - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Minute) isMatch &= date1.Minute.Equals(date2.Minute); - if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Second) isMatch &= date1.Second.Equals(date2.Second); + var isMatch = true; + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Year) + { + isMatch &= date1.Year.Equals(date2.Year); + } + + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Month) + { + isMatch &= date1.Month.Equals(date2.Month); + } + + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Day) + { + isMatch &= date1.Day.Equals(date2.Day); + } + + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Hour) + { + isMatch &= date1.Hour.Equals(date2.Hour); + } + + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Minute) + { + isMatch &= date1.Minute.Equals(date2.Minute); + } + + if (isMatch && dateTimeGrouping >= XLDateTimeGrouping.Second) + { + isMatch &= date1.Second.Equals(date2.Second); + } return isMatch; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/AutoFilters/XLFilter.cs b/ClosedXML/Excel/AutoFilters/XLFilter.cs index 42ac11220..de4c76b42 100644 --- a/ClosedXML/Excel/AutoFilters/XLFilter.cs +++ b/ClosedXML/Excel/AutoFilters/XLFilter.cs @@ -14,10 +14,10 @@ public XLFilter(XLFilterOperator op = XLFilterOperator.Equal) Operator = op; } - public Func Condition { get; set; } + public Func Condition { get; set; } public XLConnector Connector { get; set; } public XLDateTimeGrouping DateTimeGrouping { get; set; } public XLFilterOperator Operator { get; set; } - public Object Value { get; set; } + public object Value { get; set; } } } diff --git a/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs b/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs index 3217cf75d..308ab17da 100644 --- a/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs +++ b/ClosedXML/Excel/AutoFilters/XLFilterColumn.cs @@ -1,16 +1,15 @@ using System; using System.Linq; +using System.Collections.Generic; namespace ClosedXML.Excel { - using System.Collections.Generic; - internal class XLFilterColumn : IXLFilterColumn { private readonly XLAutoFilter _autoFilter; - private readonly Int32 _column; + private readonly int _column; - public XLFilterColumn(XLAutoFilter autoFilter, Int32 column) + public XLFilterColumn(XLAutoFilter autoFilter, int column) { _autoFilter = autoFilter; _column = column; @@ -21,12 +20,14 @@ public XLFilterColumn(XLAutoFilter autoFilter, Int32 column) public void Clear() { if (_autoFilter.Filters.ContainsKey(_column)) + { _autoFilter.Filters.Remove(_column); + } } public IXLFilteredColumn AddFilter(T value) where T : IComparable { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { ApplyCustomFilter(value, XLFilterOperator.Equal, v => @@ -43,11 +44,12 @@ public IXLFilteredColumn AddFilter(T value) where T : IComparable public IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTimeGrouping dateTimeGrouping) { - Func condition = date2 => XLDateTimeGroupFilteredColumn.IsMatch(date, (DateTime)date2, dateTimeGrouping); + bool condition(object date2) => XLDateTimeGroupFilteredColumn.IsMatch(date, (DateTime)date2, dateTimeGrouping); _autoFilter.IsEnabled = true; - if (_autoFilter.Filters.TryGetValue(_column, out List filterList)) + if (_autoFilter.Filters.TryGetValue(_column, out var filterList)) + { filterList.Add( new XLFilter { @@ -58,6 +60,7 @@ public IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTi DateTimeGrouping = dateTimeGrouping } ); + } else { _autoFilter.Filters.Add( @@ -83,25 +86,29 @@ public IXLDateTimeGroupFilteredColumn AddDateGroupFilter(DateTime date, XLDateTi var rows = _autoFilter.Range.Rows(2, _autoFilter.Range.RowCount()); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { if (row.Cell(_column).DataType == XLDataType.DateTime && condition(row.Cell(_column).GetDateTime())) + { row.WorksheetRow().Unhide(); + } else + { row.WorksheetRow().Hide(); + } } ws.ResumeEvents(); return new XLDateTimeGroupFilteredColumn(_autoFilter, _column); } - public void Top(Int32 value, XLTopBottomType type = XLTopBottomType.Items) + public void Top(int value, XLTopBottomType type = XLTopBottomType.Items) { _autoFilter.Column(_column).TopBottomPart = XLTopBottomPart.Top; SetTopBottom(value, type); } - public void Bottom(Int32 value, XLTopBottomType type = XLTopBottomType.Items) + public void Bottom(int value, XLTopBottomType type = XLTopBottomType.Items) { _autoFilter.Column(_column).TopBottomPart = XLTopBottomPart.Bottom; SetTopBottom(value, type, false); @@ -119,7 +126,7 @@ public void BelowAverage() public IXLFilterConnector EqualTo(T value) where T : IComparable { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { return ApplyCustomFilter(value, XLFilterOperator.Equal, v => @@ -133,7 +140,7 @@ public IXLFilterConnector EqualTo(T value) where T : IComparable public IXLFilterConnector NotEqualTo(T value) where T : IComparable { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { return ApplyCustomFilter(value, XLFilterOperator.NotEqual, v => @@ -179,54 +186,54 @@ public void NotBetween(T minValue, T maxValue) where T : IComparable LessThan(minValue).Or.GreaterThan(maxValue); } - public static Func BeginsWithFunction { get; } = (value, input) => ((string)input).StartsWith(value, StringComparison.InvariantCultureIgnoreCase); + public static Func BeginsWithFunction { get; } = (value, input) => ((string)input).StartsWith(value, StringComparison.InvariantCultureIgnoreCase); - public IXLFilterConnector BeginsWith(String value) + public IXLFilterConnector BeginsWith(string value) { return ApplyCustomFilter(value + "*", XLFilterOperator.Equal, s => BeginsWithFunction(value, s)); } - public IXLFilterConnector NotBeginsWith(String value) + public IXLFilterConnector NotBeginsWith(string value) { return ApplyCustomFilter(value + "*", XLFilterOperator.NotEqual, s => !BeginsWithFunction(value, s)); } - public static Func EndsWithFunction { get; } = (value, input) => ((string)input).EndsWith(value, StringComparison.InvariantCultureIgnoreCase); + public static Func EndsWithFunction { get; } = (value, input) => ((string)input).EndsWith(value, StringComparison.InvariantCultureIgnoreCase); - public IXLFilterConnector EndsWith(String value) + public IXLFilterConnector EndsWith(string value) { return ApplyCustomFilter("*" + value, XLFilterOperator.Equal, s => EndsWithFunction(value, s)); } - public IXLFilterConnector NotEndsWith(String value) + public IXLFilterConnector NotEndsWith(string value) { return ApplyCustomFilter("*" + value, XLFilterOperator.NotEqual, s => !EndsWithFunction(value, s)); } - public static Func ContainsFunction { get; } = (value, input) => ((string)input).IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0; + public static Func ContainsFunction { get; } = (value, input) => ((string)input).IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0; - public IXLFilterConnector Contains(String value) + public IXLFilterConnector Contains(string value) { return ApplyCustomFilter("*" + value + "*", XLFilterOperator.Equal, s => ContainsFunction(value, s)); } - public IXLFilterConnector NotContains(String value) + public IXLFilterConnector NotContains(string value) { return ApplyCustomFilter("*" + value + "*", XLFilterOperator.Equal, s => !ContainsFunction(value, s)); } public XLFilterType FilterType { get; set; } - public Int32 TopBottomValue { get; set; } + public int TopBottomValue { get; set; } public XLTopBottomType TopBottomType { get; set; } public XLTopBottomPart TopBottomPart { get; set; } public XLFilterDynamicType DynamicType { get; set; } - public Double DynamicValue { get; set; } + public double DynamicValue { get; set; } #endregion IXLFilterColumn Members - private void SetTopBottom(Int32 value, XLTopBottomType type, Boolean takeTop = true) + private void SetTopBottom(int value, XLTopBottomType type, bool takeTop = true) { _autoFilter.IsEnabled = true; _autoFilter.Column(_column).SetFilterType(XLFilterType.TopBottom) @@ -238,16 +245,16 @@ private void SetTopBottom(Int32 value, XLTopBottomType type, Boolean takeTop = t Clear(); _autoFilter.Filters.Add(_column, new List()); - Boolean addToList = true; + var addToList = true; var ws = _autoFilter.Range.Worksheet as XLWorksheet; ws.SuspendEvents(); var rows = _autoFilter.Range.Rows(2, _autoFilter.Range.RowCount()); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { - Boolean foundOne = false; - foreach (double val in values) + var foundOne = false; + foreach (var val in values) { - Func condition = v => (v as IComparable).CompareTo(val) == 0; + bool condition(object v) => (v as IComparable).CompareTo(val) == 0; if (addToList) { _autoFilter.Filters[_column].Add(new XLFilter @@ -260,12 +267,18 @@ private void SetTopBottom(Int32 value, XLTopBottomType type, Boolean takeTop = t } var cell = row.Cell(_column); - if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) continue; + if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) + { + continue; + } + row.WorksheetRow().Unhide(); foundOne = true; } if (!foundOne) + { row.WorksheetRow().Hide(); + } addToList = false; } @@ -285,7 +298,7 @@ private IEnumerable GetValues(int value, XLTopBottomType type, bool take } var numerics1 = cellsUsed.Select(c => c.GetDouble()); - Int32 valsToTake1 = numerics1.Count() * value / 100; + var valsToTake1 = numerics1.Count() * value / 100; return numerics1.OrderByDescending(d => d).Take(valsToTake1).Distinct(); } @@ -295,11 +308,11 @@ private IEnumerable GetValues(int value, XLTopBottomType type, bool take } var numerics = cellsUsed.Select(c => c.GetDouble()); - Int32 valsToTake = numerics.Count() * value / 100; + var valsToTake = numerics.Count() * value / 100; return numerics.OrderBy(d => d).Take(valsToTake).Distinct(); } - private void ShowAverage(Boolean aboveAverage) + private void ShowAverage(bool aboveAverage) { _autoFilter.IsEnabled = true; _autoFilter.Column(_column).SetFilterType(XLFilterType.Dynamic) @@ -311,17 +324,17 @@ private void ShowAverage(Boolean aboveAverage) Clear(); _autoFilter.Filters.Add(_column, new List()); - Boolean addToList = true; + var addToList = true; var ws = _autoFilter.Range.Worksheet as XLWorksheet; ws.SuspendEvents(); var rows = _autoFilter.Range.Rows(2, _autoFilter.Range.RowCount()); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { - Boolean foundOne = false; - foreach (double val in values) + var foundOne = false; + foreach (var val in values) { - Func condition = v => (v as IComparable).CompareTo(val) == 0; + bool condition(object v) => (v as IComparable).CompareTo(val) == 0; if (addToList) { _autoFilter.Filters[_column].Add(new XLFilter @@ -334,13 +347,19 @@ private void ShowAverage(Boolean aboveAverage) } var cell = row.Cell(_column); - if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) continue; + if (cell.DataType != XLDataType.Number || !condition(cell.GetDouble())) + { + continue; + } + row.WorksheetRow().Unhide(); foundOne = true; } if (!foundOne) + { row.WorksheetRow().Hide(); + } addToList = false; } @@ -352,7 +371,7 @@ private IEnumerable GetAverageValues(bool aboveAverage) { var column = _autoFilter.Range.Column(_column); var subColumn = column.Column(2, column.CellCount()); - Double average = subColumn.CellsUsed(c => c.DataType == XLDataType.Number).Select(c => c.GetDouble()) + var average = subColumn.CellsUsed(c => c.DataType == XLDataType.Number).Select(c => c.GetDouble()) .Average(); if (aboveAverage) @@ -367,7 +386,7 @@ private IEnumerable GetAverageValues(bool aboveAverage) .Where(c => c < average).Distinct(); } - private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Func condition, + private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Func condition, XLFilterType filterType = XLFilterType.Custom) where T : IComparable { @@ -389,7 +408,8 @@ private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Fu } else { - if (_autoFilter.Filters.TryGetValue(_column, out List filterList)) + if (_autoFilter.Filters.TryGetValue(_column, out var filterList)) + { filterList.Add(new XLFilter { Value = value, @@ -397,6 +417,7 @@ private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Fu Connector = XLConnector.Or, Condition = condition }); + } else { _autoFilter.Filters.Add(_column, @@ -419,7 +440,7 @@ private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Fu public IXLFilterColumn SetFilterType(XLFilterType value) { FilterType = value; return this; } - public IXLFilterColumn SetTopBottomValue(Int32 value) { TopBottomValue = value; return this; } + public IXLFilterColumn SetTopBottomValue(int value) { TopBottomValue = value; return this; } public IXLFilterColumn SetTopBottomType(XLTopBottomType value) { TopBottomType = value; return this; } @@ -427,6 +448,6 @@ private IXLFilterConnector ApplyCustomFilter(T value, XLFilterOperator op, Fu public IXLFilterColumn SetDynamicType(XLFilterDynamicType value) { DynamicType = value; return this; } - public IXLFilterColumn SetDynamicValue(Double value) { DynamicValue = value; return this; } + public IXLFilterColumn SetDynamicValue(double value) { DynamicValue = value; return this; } } } diff --git a/ClosedXML/Excel/AutoFilters/XLFilterConnector.cs b/ClosedXML/Excel/AutoFilters/XLFilterConnector.cs index 3aac0ecfc..34d284a50 100644 --- a/ClosedXML/Excel/AutoFilters/XLFilterConnector.cs +++ b/ClosedXML/Excel/AutoFilters/XLFilterConnector.cs @@ -1,16 +1,11 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLFilterConnector : IXLFilterConnector { private readonly XLAutoFilter _autoFilter; - private readonly Int32 _column; + private readonly int _column; - public XLFilterConnector(XLAutoFilter autoFilter, Int32 column) + public XLFilterConnector(XLAutoFilter autoFilter, int column) { _autoFilter = autoFilter; _column = column; @@ -18,15 +13,9 @@ public XLFilterConnector(XLAutoFilter autoFilter, Int32 column) #region IXLFilterConnector Members - public IXLCustomFilteredColumn And - { - get { return new XLCustomFilteredColumn(_autoFilter, _column, XLConnector.And); } - } + public IXLCustomFilteredColumn And => new XLCustomFilteredColumn(_autoFilter, _column, XLConnector.And); - public IXLCustomFilteredColumn Or - { - get { return new XLCustomFilteredColumn(_autoFilter, _column, XLConnector.Or); } - } + public IXLCustomFilteredColumn Or => new XLCustomFilteredColumn(_autoFilter, _column, XLConnector.Or); #endregion } diff --git a/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs b/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs index fde9dbad2..734172596 100644 --- a/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs +++ b/ClosedXML/Excel/AutoFilters/XLFilteredColumn.cs @@ -5,9 +5,9 @@ namespace ClosedXML.Excel internal class XLFilteredColumn : IXLFilteredColumn { private readonly XLAutoFilter _autoFilter; - private readonly Int32 _column; + private readonly int _column; - public XLFilteredColumn(XLAutoFilter autoFilter, Int32 column) + public XLFilteredColumn(XLAutoFilter autoFilter, int column) { _autoFilter = autoFilter; _column = column; @@ -17,9 +17,9 @@ public XLFilteredColumn(XLAutoFilter autoFilter, Int32 column) public IXLFilteredColumn AddFilter(T value) where T : IComparable { - Func condition; - Boolean isText; - if (typeof(T) == typeof(String)) + Func condition; + bool isText; + if (typeof(T) == typeof(string)) { condition = v => v.ToString().Equals(value.ToString(), StringComparison.InvariantCultureIgnoreCase); isText = true; @@ -40,7 +40,7 @@ public IXLFilteredColumn AddFilter(T value) where T : IComparable var rows = _autoFilter.Range.Rows(2, _autoFilter.Range.RowCount()); - foreach (IXLRangeRow row in rows) + foreach (var row in rows) { if ((isText && condition(row.Cell(_column).GetString())) || (!isText && row.Cell(_column).DataType == XLDataType.Number && diff --git a/ClosedXML/Excel/Caching/XLRepositoryBase.cs b/ClosedXML/Excel/Caching/XLRepositoryBase.cs index 347bf36e2..ee68f0302 100644 --- a/ClosedXML/Excel/Caching/XLRepositoryBase.cs +++ b/ClosedXML/Excel/Caching/XLRepositoryBase.cs @@ -41,7 +41,7 @@ protected XLRepositoryBase(Func createNew, IEqualityComparer /// True if entry exists and alive, false otherwise. public bool ContainsKey(ref Tkey key, out Tvalue value) { - if (_storage.TryGetValue(key, out WeakReference cachedReference)) + if (_storage.TryGetValue(key, out var cachedReference)) { value = cachedReference.Target as Tvalue; return value != null; @@ -62,11 +62,13 @@ public bool ContainsKey(ref Tkey key, out Tvalue value) public Tvalue Store(ref Tkey key, Tvalue value) { if (value == null) + { return null; + } do { - if (_storage.TryGetValue(key, out WeakReference cachedReference) && + if (_storage.TryGetValue(key, out var cachedReference) && cachedReference.Target is Tvalue storedValue) { return storedValue; @@ -78,20 +80,20 @@ public Tvalue Store(ref Tkey key, Tvalue value) public Tvalue GetOrCreate(ref Tkey key) { - if (_storage.TryGetValue(key, out WeakReference cachedReference) && + if (_storage.TryGetValue(key, out var cachedReference) && cachedReference.Target is Tvalue storedValue) { return storedValue; } - _storage.TryRemove(key, out WeakReference _); + _storage.TryRemove(key, out var _); var value = _createNew(key); return Store(ref key, value); } public Tvalue Replace(ref Tkey oldKey, ref Tkey newKey) { - if (_storage.TryRemove(oldKey, out WeakReference cachedReference) && cachedReference != null) + if (_storage.TryRemove(oldKey, out var cachedReference) && cachedReference != null) { _storage.TryAdd(newKey, cachedReference); return GetOrCreate(ref newKey); @@ -102,7 +104,7 @@ public Tvalue Replace(ref Tkey oldKey, ref Tkey newKey) public void Remove(ref Tkey key) { - _storage.TryRemove(key, out WeakReference _); + _storage.TryRemove(key, out var _); } public override void Clear() @@ -121,7 +123,7 @@ public IEnumerator GetEnumerator() var val = pair.Value.Target as Tvalue; if (val == null) { - _storage.TryRemove(pair.Key, out WeakReference _); + _storage.TryRemove(pair.Key, out var _); } return val; }) diff --git a/ClosedXML/Excel/CalcEngine/CalcEngine.cs b/ClosedXML/Excel/CalcEngine/CalcEngine.cs index 020cc1a6d..8133f4bc5 100644 --- a/ClosedXML/Excel/CalcEngine/CalcEngine.cs +++ b/ClosedXML/Excel/CalcEngine/CalcEngine.cs @@ -35,7 +35,7 @@ internal class CalcEngine private Token _nextToken; // next token being parsed. to be used by Peek private Dictionary _tkTbl; // table with tokens (+, -, etc) private Dictionary _fnTbl; // table with constants and functions (pi, sin, etc) - private Dictionary _vars; // table with variables + private readonly Dictionary _vars; // table with variables private object _dataContext; // object with properties private bool _optimize; // optimize expressions when parsing protected ExpressionCache _cache; // cache with parsed expressions @@ -83,20 +83,28 @@ public Expression Parse(string expression) // skip leading equals sign if (_len > 0 && _expr[0] == '=') + { _ptr++; + } // skip leading +'s while (_len > _ptr && _expr[_ptr] == '+') + { _ptr++; + } // parse the expression var expr = ParseExpression(); // check for errors if (_currentToken.ID == TKID.OPEN) + { Throw("Unknown function: " + expr.LastParseItem); + } else if (_currentToken.ID != TKID.END) + { Throw("Expected end of expression"); + } // optimize expression if (_optimize) @@ -224,18 +232,12 @@ public virtual object DataContext /// /// Gets the dictionary that contains function definitions. /// - public Dictionary Functions - { - get { return _fnTbl; } - } + public Dictionary Functions => _fnTbl; /// /// Gets the dictionary that contains simple variables (not in the DataContext). /// - public Dictionary Variables - { - get { return _vars; } - } + public Dictionary Variables => _vars; /// /// Gets or sets the to use when parsing numbers and dates. @@ -415,7 +417,10 @@ private Expression ParseUnary() do { if (_currentToken.ID == TKID.SUB) + { sign = -sign; + } + GetToken(); } while (_currentToken.Type == TKTYPE.ADDSUB); var a = ParseAtom(); @@ -452,12 +457,16 @@ private Expression ParseAtom() if (PeekToken().ID == TKID.OPEN) { // look for functions - var foundFunction = _fnTbl.TryGetValue(id, out FunctionDefinition functionDefinition); + var foundFunction = _fnTbl.TryGetValue(id, out var functionDefinition); if (!foundFunction && id.StartsWith($"{defaultFunctionNameSpace}.")) + { foundFunction = _fnTbl.TryGetValue(id.Substring(defaultFunctionNameSpace.Length + 1), out functionDefinition); + } if (!foundFunction) + { throw new NameNotRecognizedException($"The identifier `{id}` was not recognised."); + } var p = GetParameters(); var pCnt = p == null ? 0 : p.Count; @@ -483,7 +492,9 @@ private Expression ParseAtom() // look for external objects var xObj = GetExternalObject(id); if (xObj == null) + { throw new NameNotRecognizedException($"The identifier `{id}` was not recognised."); + } x = new XObjectExpression(xObj); break; @@ -532,7 +543,7 @@ private Expression ParseAtom() #region ** parser - private static IDictionary matchingClosingSymbols = new Dictionary() + private static readonly IDictionary matchingClosingSymbols = new Dictionary { { '\'', '\'' }, { '[', ']' } @@ -562,13 +573,13 @@ private Token ParseToken() var isLetter = char.IsLetter(c); var isDigit = char.IsDigit(c); - var isEnclosed = matchingClosingSymbols.TryGetValue(c, out char matchingClosingSymbol); + var isEnclosed = matchingClosingSymbols.TryGetValue(c, out var matchingClosingSymbol); if (!isLetter && !isDigit && !isEnclosed) { // if this is a number starting with a decimal, don't parse as operator var nxt = _ptr + 1 < _len ? _expr[_ptr + 1] : '0'; - bool isNumber = c == _decimal && char.IsDigit(nxt); + var isNumber = c == _decimal && char.IsDigit(nxt); if (!isNumber) { // look up localized list separator @@ -579,7 +590,7 @@ private Token ParseToken() } // look up single-char tokens on table - if (_tkTbl.TryGetValue(c, out Token t)) + if (_tkTbl.TryGetValue(c, out var t)) { // save token we found var token = t; @@ -633,7 +644,11 @@ private Token ParseToken() { sci = true; c = _expr[_ptr + i + 1]; - if (c == '+' || c == '-') i++; + if (c == '+' || c == '-') + { + i++; + } + continue; } @@ -673,9 +688,17 @@ private Token ParseToken() for (i = 1; i + _ptr < _len; i++) { c = _expr[_ptr + i]; - if (c != '\"') continue; - char cNext = i + _ptr < _len - 1 ? _expr[_ptr + i + 1] : ' '; - if (cNext != '\"') break; + if (c != '\"') + { + continue; + } + + var cNext = i + _ptr < _len - 1 ? _expr[_ptr + i + 1] : ' '; + if (cNext != '\"') + { + break; + } + i++; } @@ -725,14 +748,18 @@ private Token ParseToken() var disallowedSymbols = new List() { '\\', '/', '*', '[', ':', '?' }; if (isEnclosed && disallowedSymbols.Contains(c)) + { break; + } var allowedSymbols = new List() { '_', '.' }; if (!isLetter && !isDigit && !(isEnclosed || allowedSymbols.Contains(c)) && (_idChars == null || !_idChars.Contains(c))) + { break; + } } // got identifier @@ -741,7 +768,9 @@ private Token ParseToken() // If we have a true/false, return a literal if (bool.TryParse(id, out var b)) + { return new Token(b, TKID.ATOM, TKTYPE.LITERAL); + } return new Token(id, TKID.ATOM, TKTYPE.IDENTIFIER); } @@ -806,9 +835,13 @@ private List GetParameters() // e.g. myfun(a, b, c+2) // make sure the list was closed correctly if (_currentToken.ID == TKID.OPEN) + { Throw("Unknown function: " + expr.LastParseItem); + } else if (_currentToken.ID != TKID.CLOSE) + { Throw("Syntax error: expected ')'"); + } // done return parms; @@ -863,4 +896,4 @@ private static void Throw(string msg) /// parameters to be used in the function call. /// The function result. internal delegate object CalcEngineFunction(List parms); -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/CalcEngineHelpers.cs b/ClosedXML/Excel/CalcEngine/CalcEngineHelpers.cs index 4b0f586f0..74467080e 100644 --- a/ClosedXML/Excel/CalcEngine/CalcEngineHelpers.cs +++ b/ClosedXML/Excel/CalcEngine/CalcEngineHelpers.cs @@ -7,7 +7,7 @@ namespace ClosedXML.Excel.CalcEngine { internal static class CalcEngineHelpers { - private static Lazy>> patternReplacements = + private static readonly Lazy>> patternReplacements = new Lazy>>(() => { // key: the literal string to match @@ -31,24 +31,45 @@ internal static bool ValueSatisfiesCriteria(object value, object criteria, CalcE } // Excel treats TRUE and 1 as unequal, but LibreOffice treats them as equal. We follow Excel's convention - if (criteria is Boolean b1) - return (value is Boolean b2) && b1.Equals(b2); + if (criteria is bool b1) + { + return (value is bool b2) && b1.Equals(b2); + } - if (value is Boolean) return false; + if (value is bool) + { + return false; + } // if criteria is a number, straight comparison - Double cdbl; - if (criteria is Double dbl2) cdbl = dbl2; - else if (criteria is Int32 i) cdbl = i; // results of DATE function can be an integer - else if (criteria is DateTime dt) cdbl = dt.ToOADate(); - else if (criteria is TimeSpan ts) cdbl = ts.TotalDays; - else if (criteria is String cs) + double cdbl; + if (criteria is double dbl2) + { + cdbl = dbl2; + } + else if (criteria is int i) + { + cdbl = i; // results of DATE function can be an integer + } + else if (criteria is DateTime dt) + { + cdbl = dt.ToOADate(); + } + else if (criteria is TimeSpan ts) + { + cdbl = ts.TotalDays; + } + else if (criteria is string cs) { if (value is string && (value as string).Trim().Length == 0) + { return cs.Length == 0; + } if (cs.Length == 0) + { return cs.Equals(value); + } // if criteria is an expression (e.g. ">20"), use calc engine if ((cs[0] == '=' && cs.IndexOfAny(new[] { '*', '?' }) < 0) @@ -62,7 +83,7 @@ internal static bool ValueSatisfiesCriteria(object value, object criteria, CalcE var pattern = @"([\w\s]+)(\W+)(\w+)"; var m = Regex.Match(expression, pattern); if (m.Groups.Count == 4 - && (!double.TryParse(m.Groups[1].Value, out double d) || + && (!double.TryParse(m.Groups[1].Value, out var d) || !double.TryParse(m.Groups[3].Value, out d))) { expression = string.Format("\"{0}\"{1}\"{2}\"", @@ -78,11 +99,14 @@ internal static bool ValueSatisfiesCriteria(object value, object criteria, CalcE // if criteria is a regular expression, use regex if (cs.IndexOfAny(new[] { '*', '?' }) > -1) { - if (cs[0] == '=') cs = cs.Substring(1); + if (cs[0] == '=') + { + cs = cs.Substring(1); + } var pattern = Regex.Replace( cs, - "(" + String.Join( + "(" + string.Join( "|", patternReplacements.Value.Values.Select(t => t.Item1)) + ")", @@ -94,35 +118,62 @@ internal static bool ValueSatisfiesCriteria(object value, object criteria, CalcE // straight string comparison if (value is string vs) + { return vs.Equals(cs, StringComparison.OrdinalIgnoreCase); + } else + { return string.Equals(value.ToString(), cs, StringComparison.OrdinalIgnoreCase); + } } else + { throw new NotImplementedException(); + } - Double vdbl; - if (value is Double dbl) vdbl = dbl; - else if (value is Int32 i) vdbl = i; - else if (value is DateTime dt) vdbl = dt.ToOADate(); - else if (value is TimeSpan ts) vdbl = ts.TotalDays; - else if (value is String s) + double vdbl; + if (value is double dbl) + { + vdbl = dbl; + } + else if (value is int i) + { + vdbl = i; + } + else if (value is DateTime dt) + { + vdbl = dt.ToOADate(); + } + else if (value is TimeSpan ts) + { + vdbl = ts.TotalDays; + } + else if (value is string s) { - if (!Double.TryParse(s, out vdbl)) return false; + if (!double.TryParse(s, out vdbl)) + { + return false; + } } else + { throw new NotImplementedException(); + } - return Math.Abs(vdbl - cdbl) < Double.Epsilon; + return Math.Abs(vdbl - cdbl) < double.Epsilon; } internal static bool ValueIsBlank(object value) { if (value == null) + { return true; + } if (value is string s) + { return s.Length == 0; + } return false; } @@ -137,8 +188,11 @@ internal static long GetTotalCellsCount(XObjectExpression rangeExpression) { var range = (rangeExpression?.Value as CellRangeReference)?.Range; if (range == null) + { return 0; - return (long)(range.LastColumn().ColumnNumber() - range.FirstColumn().ColumnNumber() + 1) * + } + + return (range.LastColumn().ColumnNumber() - range.FirstColumn().ColumnNumber() + 1) * (long)(range.LastRow().RowNumber() - range.FirstRow().RowNumber() + 1); } } diff --git a/ClosedXML/Excel/CalcEngine/CellRangeReference.cs b/ClosedXML/Excel/CalcEngine/CellRangeReference.cs index eadb0d23f..e1b2982e0 100644 --- a/ClosedXML/Excel/CalcEngine/CellRangeReference.cs +++ b/ClosedXML/Excel/CalcEngine/CellRangeReference.cs @@ -24,7 +24,9 @@ public object GetValue() public IEnumerator GetEnumerator() { if (Range.Worksheet.IsEmpty(XLCellsUsedOptions.AllContents)) + { yield break; + } var lastCellAddress = Range.Worksheet.LastCellUsed().Address; var maxRow = Math.Min(Range.RangeAddress.LastAddress.RowNumber, lastCellAddress.RowNumber); @@ -37,10 +39,12 @@ public IEnumerator GetEnumerator() ); foreach (var c in trimmedRange.CellValues()) + { yield return c; + } } - private Boolean _evaluating; + private bool _evaluating; // ** implementation private object GetValue(IXLCell cell) @@ -53,8 +57,10 @@ private object GetValue(IXLCell cell) { _evaluating = true; var f = cell.FormulaA1; - if (String.IsNullOrWhiteSpace(f)) + if (string.IsNullOrWhiteSpace(f)) + { return cell.Value; + } else { return (cell as XLCell).Evaluate(); diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/CellReferenceException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/CellReferenceException.cs index 91e219ea0..acbeddcf1 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/CellReferenceException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/CellReferenceException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// formula. /// Corresponds to the #REF! error in Excel /// - /// + /// public class CellReferenceException : CalcEngineException { internal CellReferenceException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/CellValueException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/CellValueException.cs index ad129dcf4..6d94ae3ff 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/CellValueException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/CellValueException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// text. /// Corresponds to the #VALUE! error in Excel /// - /// + /// public class CellValueException : CalcEngineException { internal CellValueException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/DivisionByZeroException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/DivisionByZeroException.cs index 8bc6b7b0d..d15cb8610 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/DivisionByZeroException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/DivisionByZeroException.cs @@ -7,7 +7,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// contains the value 0 or is blank. /// Corresponds to the #DIV/0! error in Excel /// - /// + /// public class DivisionByZeroException : CalcEngineException { internal DivisionByZeroException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/NameNotRecognizedException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/NameNotRecognizedException.cs index 7a9307511..488719f58 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/NameNotRecognizedException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/NameNotRecognizedException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// marks around a text string in a formula. /// Corresponds to the #NAME? error in Excel /// - /// + /// public class NameNotRecognizedException : CalcEngineException { internal NameNotRecognizedException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/NoValueAvailableException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/NoValueAvailableException.cs index 318fb9ae0..d1370860b 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/NoValueAvailableException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/NoValueAvailableException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// don’t yet have a necessary value. /// Corresponds to the #N/A error in Excel. /// - /// + /// public class NoValueAvailableException : CalcEngineException { internal NoValueAvailableException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/NullValueException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/NullValueException.cs index 5cc74bc3a..6369cfa1a 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/NullValueException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/NullValueException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// between ranges used in function arguments. /// Corresponds to the #NULL! error in Excel /// - /// + /// public class NullValueException : CalcEngineException { internal NullValueException() diff --git a/ClosedXML/Excel/CalcEngine/Exceptions/NumberException.cs b/ClosedXML/Excel/CalcEngine/Exceptions/NumberException.cs index 7d248f535..edcd0cb8f 100644 --- a/ClosedXML/Excel/CalcEngine/Exceptions/NumberException.cs +++ b/ClosedXML/Excel/CalcEngine/Exceptions/NumberException.cs @@ -8,7 +8,7 @@ namespace ClosedXML.Excel.CalcEngine.Exceptions /// to be represented in the worksheet. /// Corresponds to the #NUM! error in Excel /// - /// + /// public class NumberException : CalcEngineException { internal NumberException() diff --git a/ClosedXML/Excel/CalcEngine/Expression.cs b/ClosedXML/Excel/CalcEngine/Expression.cs index b038c16a9..e2ac91e8b 100644 --- a/ClosedXML/Excel/CalcEngine/Expression.cs +++ b/ClosedXML/Excel/CalcEngine/Expression.cs @@ -2,7 +2,6 @@ using System; using System.Collections; using System.Collections.Generic; -using System.Globalization; using System.Linq; using System.Threading; @@ -81,15 +80,21 @@ public virtual Expression Optimize() public static implicit operator string(Expression x) { if (x is ErrorExpression) + { (x as ErrorExpression).ThrowApplicableException(); + } var v = x.Evaluate(); if (v == null) + { return string.Empty; + } if (v is bool b) + { return b.ToString().ToUpper(); + } return v.ToString(); } @@ -97,7 +102,9 @@ public static implicit operator string(Expression x) public static implicit operator double(Expression x) { if (x is ErrorExpression) + { (x as ErrorExpression).ThrowApplicableException(); + } // evaluate var v = x.Evaluate(); @@ -138,14 +145,16 @@ public static implicit operator double(Expression x) } // handle everything else - CultureInfo _ci = Thread.CurrentThread.CurrentCulture; + var _ci = Thread.CurrentThread.CurrentCulture; return (double)Convert.ChangeType(v, typeof(double), _ci); } public static implicit operator bool(Expression x) { if (x is ErrorExpression) + { (x as ErrorExpression).ThrowApplicableException(); + } // evaluate var v = x.Evaluate(); @@ -175,7 +184,9 @@ public static implicit operator bool(Expression x) public static implicit operator DateTime(Expression x) { if (x is ErrorExpression) + { (x as ErrorExpression).ThrowApplicableException(); + } // evaluate var v = x.Evaluate(); @@ -198,7 +209,7 @@ public static implicit operator DateTime(Expression x) } // handle everything else - CultureInfo _ci = Thread.CurrentThread.CurrentCulture; + var _ci = Thread.CurrentThread.CurrentCulture; return (DateTime)Convert.ChangeType(v, typeof(DateTime), _ci); } @@ -211,7 +222,7 @@ public static implicit operator DateTime(Expression x) public int CompareTo(Expression other) { // get both values - var c1 = this.Evaluate() as IComparable; + var c1 = Evaluate() as IComparable; var c2 = other.Evaluate() as IComparable; // handle nulls @@ -234,11 +245,17 @@ public int CompareTo(Expression other) try { if (c1 is DateTime) - c2 = ((DateTime)other); + { + c2 = (DateTime)other; + } else if (c2 is DateTime) - c1 = ((DateTime)this); + { + c1 = (DateTime)this; + } else + { c2 = Convert.ChangeType(c2, c1.GetType()) as IComparable; + } } catch (InvalidCastException) { return -1; } catch (FormatException) { return -1; } @@ -248,9 +265,13 @@ public int CompareTo(Expression other) // String comparisons should be case insensitive if (c1 is string s1 && c2 is string s2) + { return StringComparer.OrdinalIgnoreCase.Compare(s1, s2); + } else + { return c1.CompareTo(c2); + } } #endregion ** IComparable @@ -259,10 +280,7 @@ public int CompareTo(Expression other) #region ** ExpressionBase - public override string LastParseItem - { - get { return _token?.Value?.ToString() ?? "Unknown value"; } - } + public override string LastParseItem => _token?.Value?.ToString() ?? "Unknown value"; #endregion ** ExpressionBase } @@ -281,7 +299,7 @@ public UnaryExpression(Token tk, Expression expr) : base(tk) public Expression Expression { get; private set; } // ** object model - override public object Evaluate() + public override object Evaluate() { switch (_token.ID) { @@ -298,14 +316,11 @@ public override Expression Optimize() { Expression = Expression.Optimize(); return Expression._token.Type == TKTYPE.LITERAL - ? new Expression(this.Evaluate()) + ? new Expression(Evaluate()) : this; } - public override string LastParseItem - { - get { return Expression.LastParseItem; } - } + public override string LastParseItem => Expression.LastParseItem; } /// @@ -324,7 +339,7 @@ public BinaryExpression(Token tk, Expression exprLeft, Expression exprRight) : b public Expression RightExpression { get; private set; } // ** object model - override public object Evaluate() + public override object Evaluate() { // handle comparisons if (_token.Type == TKTYPE.COMPARE) @@ -358,31 +373,61 @@ override public object Evaluate() case TKID.DIV: if (Math.Abs((double)RightExpression) < double.Epsilon) + { throw new DivisionByZeroException(); + } return (double)LeftExpression / (double)RightExpression; case TKID.DIVINT: if (Math.Abs((double)RightExpression) < double.Epsilon) + { throw new DivisionByZeroException(); + } return (double)(int)((double)LeftExpression / (double)RightExpression); case TKID.MOD: if (Math.Abs((double)RightExpression) < double.Epsilon) + { throw new DivisionByZeroException(); + } return (double)(int)((double)LeftExpression % (double)RightExpression); case TKID.POWER: var a = (double)LeftExpression; var b = (double)RightExpression; - if (b == 0.0) return 1.0; - if (b == 0.5) return Math.Sqrt(a); - if (b == 1.0) return a; - if (b == 2.0) return a * a; - if (b == 3.0) return a * a * a; - if (b == 4.0) return a * a * a * a; + if (XLHelper.AreEqual(b, 0.0)) + { + return 1.0; + } + + if (XLHelper.AreEqual(b, 0.5)) + { + return Math.Sqrt(a); + } + + if (XLHelper.AreEqual(b, 1.0)) + { + return a; + } + + if (XLHelper.AreEqual(b, 2.0)) + { + return a * a; + } + + if (XLHelper.AreEqual(b, 3.0)) + { + return a * a * a; + } + + if (XLHelper.AreEqual(b, 4.0)) + { + return a * a * a * a; + } + return Math.Pow((double)LeftExpression, (double)RightExpression); } throw new ArgumentException("Bad expression."); @@ -393,14 +438,11 @@ public override Expression Optimize() LeftExpression = LeftExpression.Optimize(); RightExpression = RightExpression.Optimize(); return LeftExpression._token.Type == TKTYPE.LITERAL && RightExpression._token.Type == TKTYPE.LITERAL - ? new Expression(this.Evaluate()) + ? new Expression(Evaluate()) : this; } - public override string LastParseItem - { - get { return RightExpression.LastParseItem; } - } + public override string LastParseItem => RightExpression.LastParseItem; } /// @@ -419,7 +461,7 @@ public FunctionExpression(FunctionDefinition function, List parms) } // ** object model - override public object Evaluate() + public override object Evaluate() { return FunctionDefinition.Function(Parameters); } @@ -429,10 +471,10 @@ override public object Evaluate() public override Expression Optimize() { - bool allLits = true; + var allLits = true; if (Parameters != null) { - for (int i = 0; i < Parameters.Count; i++) + for (var i = 0; i < Parameters.Count; i++) { var p = Parameters[i].Optimize(); Parameters[i] = p; @@ -443,14 +485,11 @@ public override Expression Optimize() } } return allLits - ? new Expression(this.Evaluate()) + ? new Expression(Evaluate()) : this; } - public override string LastParseItem - { - get { return Parameters.Last().LastParseItem; } - } + public override string LastParseItem => Parameters.Last().LastParseItem; } /// @@ -472,10 +511,7 @@ public override object Evaluate() return _dct[_name]; } - public override string LastParseItem - { - get { return _name; } - } + public override string LastParseItem => _name; } /// @@ -491,14 +527,13 @@ internal XObjectExpression(object value) _value = value; } - public object Value { get { return _value; } } + public object Value => _value; // ** object model public override object Evaluate() { // use IValueObject if available - var iv = _value as IValueObject; - if (iv != null) + if (_value is IValueObject iv) { return iv.GetValue(); } @@ -516,7 +551,9 @@ public IEnumerator GetEnumerator() else if (_value is IEnumerable ie) { foreach (var o in ie) + { yield return o; + } } else { @@ -524,10 +561,7 @@ public IEnumerator GetEnumerator() } } - public override string LastParseItem - { - get { return Value.ToString(); } - } + public override string LastParseItem => Value.ToString(); } /// @@ -537,14 +571,11 @@ internal class EmptyValueExpression : Expression { internal EmptyValueExpression() // Ensures a token of type LITERAL, with value of null is created - : base(value: null) + : base(value: null) { } - public override string LastParseItem - { - get { return ""; } - } + public override string LastParseItem => ""; } internal class ErrorExpression : Expression @@ -566,7 +597,7 @@ internal ErrorExpression(ExpressionErrorType eet) public override object Evaluate() { - return this._token.Value; + return _token.Value; } public void ThrowApplicableException() @@ -602,4 +633,4 @@ public interface IValueObject { object GetValue(); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/ExpressionCache.cs b/ClosedXML/Excel/CalcEngine/ExpressionCache.cs index b688271db..fdbd26692 100644 --- a/ClosedXML/Excel/CalcEngine/ExpressionCache.cs +++ b/ClosedXML/Excel/CalcEngine/ExpressionCache.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Text; namespace ClosedXML.Excel.CalcEngine { @@ -13,8 +12,8 @@ namespace ClosedXML.Excel.CalcEngine /// class ExpressionCache { - Dictionary _dct; - CalcEngine _ce; + readonly Dictionary _dct; + readonly CalcEngine _ce; int _hitCount; public ExpressionCache(CalcEngine ce) @@ -29,7 +28,7 @@ public Expression this[string expression] get { Expression x; - if (_dct.TryGetValue(expression, out WeakReference wr) && wr.IsAlive) + if (_dct.TryGetValue(expression, out var wr) && wr.IsAlive) { x = wr.Target as Expression; } @@ -53,7 +52,7 @@ public Expression this[string expression] // remove all dead references from the cache void RemoveDeadReferences() { - for (bool done = false; !done; ) + for (var done = false; !done; ) { done = true; foreach (var k in _dct.Keys) diff --git a/ClosedXML/Excel/CalcEngine/ExpressionParseException.cs b/ClosedXML/Excel/CalcEngine/ExpressionParseException.cs index 2de2293f4..cf7d5174f 100644 --- a/ClosedXML/Excel/CalcEngine/ExpressionParseException.cs +++ b/ClosedXML/Excel/CalcEngine/ExpressionParseException.cs @@ -1,5 +1,4 @@ using System; -using System.Text; namespace ClosedXML.Excel.CalcEngine { diff --git a/ClosedXML/Excel/CalcEngine/FunctionDefinition.cs b/ClosedXML/Excel/CalcEngine/FunctionDefinition.cs index 5f4a55ca2..f65f921c8 100644 --- a/ClosedXML/Excel/CalcEngine/FunctionDefinition.cs +++ b/ClosedXML/Excel/CalcEngine/FunctionDefinition.cs @@ -1,7 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Text; - namespace ClosedXML.Excel.CalcEngine { /// diff --git a/ClosedXML/Excel/CalcEngine/Functions/Database.cs b/ClosedXML/Excel/CalcEngine/Functions/Database.cs index 1c2574746..6ad849c31 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Database.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Database.cs @@ -1,7 +1,4 @@ -using System; using System.Collections.Generic; -using System.Linq; -using System.Text; namespace ClosedXML.Excel.CalcEngine.Functions { diff --git a/ClosedXML/Excel/CalcEngine/Functions/DateAndTime.cs b/ClosedXML/Excel/CalcEngine/Functions/DateAndTime.cs index 2e11991c8..6259929c7 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/DateAndTime.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/DateAndTime.cs @@ -49,11 +49,13 @@ private static int BusinessDaysUntil(DateTime firstDay, DateTime lastDay, IEnume firstDay = firstDay.Date; lastDay = lastDay.Date; if (firstDay > lastDay) + { return -BusinessDaysUntil(lastDay, firstDay, bankHolidays); + } - TimeSpan span = lastDay - firstDay; - int businessDays = span.Days + 1; - int fullWeekCount = businessDays / 7; + var span = lastDay - firstDay; + var businessDays = span.Days + 1; + var fullWeekCount = businessDays / 7; // find out if there are weekends during the time exceedng the full weeks if (businessDays > fullWeekCount * 7) { @@ -62,16 +64,25 @@ private static int BusinessDaysUntil(DateTime firstDay, DateTime lastDay, IEnume var firstDayOfWeek = (int)firstDay.DayOfWeek; var lastDayOfWeek = (int)lastDay.DayOfWeek; if (lastDayOfWeek < firstDayOfWeek) + { lastDayOfWeek += 7; + } + if (firstDayOfWeek <= 6) { if (lastDayOfWeek >= 7)// Both Saturday and Sunday are in the remaining time interval + { businessDays -= 2; + } else if (lastDayOfWeek >= 6)// Only Saturday is in the remaining time interval + { businessDays -= 1; + } } else if (firstDayOfWeek <= 7 && lastDayOfWeek >= 7)// Only Sunday is in the remaining time interval + { businessDays -= 1; + } } // subtract the weekends during the full weeks in the interval @@ -81,7 +92,9 @@ private static int BusinessDaysUntil(DateTime firstDay, DateTime lastDay, IEnume foreach (var bh in bankHolidays) { if (firstDay <= bh && bh <= lastDay) + { --businessDays; + } } return businessDays; @@ -100,7 +113,7 @@ private static object Date(List p) month -= (int)Math.Floor((double)(month - 1d) / 12.0) * 12; } - int daysAdjustment = 0; + var daysAdjustment = 0; if (day > DateTime.DaysInMonth(year, month)) { daysAdjustment = day - DateTime.DaysInMonth(year, month); @@ -122,9 +135,11 @@ private static object Datedif(List p) string unit = p[2]; if (startDate > endDate) + { throw new NumberException("The start date is greater than the end date"); + } - return (unit.ToUpper()) switch + return unit.ToUpper(CultureInfo.InvariantCulture) switch { "Y" => endDate.Year - startDate.Year - (new DateTime(startDate.Year, endDate.Month, endDate.Day) < startDate ? 1 : 0), "M" => Math.Truncate((endDate.Year - startDate.Year) * 12d + endDate.Month - startDate.Month - (endDate.Day < startDate.Day ? 1 : 0)), @@ -162,17 +177,25 @@ private static object Days(List p) type = p[0]._token.Value.GetType(); if (type == typeof(string)) + { end_date = (int)Datevalue(new List() { p[0] }); + } else + { end_date = (int)p[0]; + } int start_date; type = p[1]._token.Value.GetType(); if (type == typeof(string)) + { start_date = (int)Datevalue(new List() { p[1] }); + } else + { start_date = (int)p[1]; + } return end_date - start_date; } @@ -186,7 +209,7 @@ private static object Days360(List p) return Days360(date1, date2, isEuropean); } - private static Int32 Days360(DateTime date1, DateTime date2, Boolean isEuropean) + private static int Days360(DateTime date1, DateTime date2, bool isEuropean) { var d1 = date1.Day; var m1 = date1.Month; @@ -197,13 +220,27 @@ private static Int32 Days360(DateTime date1, DateTime date2, Boolean isEuropean) if (isEuropean) { - if (d1 == 31) d1 = 30; - if (d2 == 31) d2 = 30; + if (d1 == 31) + { + d1 = 30; + } + + if (d2 == 31) + { + d2 = 30; + } } else { - if (d1 == 31) d1 = 30; - if (d2 == 31 && d1 == 30) d2 = 30; + if (d1 == 31) + { + d1 = 30; + } + + if (d2 == 31 && d1 == 30) + { + d2 = 30; + } } return 360 * (y2 - y1) + 30 * (m2 - m1) + (d2 - d1); @@ -227,11 +264,14 @@ private static object Eomonth(List p) return new DateTime(retDate.Year, retDate.Month, DateTime.DaysInMonth(retDate.Year, retDate.Month)); } - private static Double GetYearAverage(DateTime date1, DateTime date2) + private static double GetYearAverage(DateTime date1, DateTime date2) { - var daysInYears = new List(); - for (int year = date1.Year; year <= date2.Year; year++) + var daysInYears = new List(); + for (var year = date1.Year; year <= date2.Year; year++) + { daysInYears.Add(DateTime.IsLeapYear(year) ? 366 : 365); + } + return daysInYears.Average(); } @@ -250,7 +290,7 @@ private static object IsoWeekNum(List p) // Seriously cheat. If its Monday, Tuesday or Wednesday, then it'll // be the same week# as whatever Thursday, Friday or Saturday are, // and we always get those right - DayOfWeek day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(date); + var day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(date); if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday) { date = date.AddDays(3); @@ -327,8 +367,15 @@ private static object Weekday(List p) var dayOfWeek = (int)((DateTime)p[0]).DayOfWeek; var retType = p.Count == 2 ? (int)p[1] : 1; - if (retType == 2) return dayOfWeek; - if (retType == 1) return dayOfWeek + 1; + if (retType == 2) + { + return dayOfWeek; + } + + if (retType == 1) + { + return dayOfWeek + 1; + } return dayOfWeek - 1; } @@ -338,7 +385,7 @@ private static object Weeknum(List p) var date = (DateTime)p[0]; var retType = p.Count == 2 ? (int)p[1] : 1; - DayOfWeek dayOfWeek = retType == 1 ? DayOfWeek.Sunday : DayOfWeek.Monday; + var dayOfWeek = retType == 1 ? DayOfWeek.Sunday : DayOfWeek.Monday; var cal = new GregorianCalendar(GregorianCalendarTypes.Localized); var val = cal.GetWeekOfYear(date, CalendarWeekRule.FirstDay, dayOfWeek); @@ -350,7 +397,10 @@ private static object Workday(List p) var startDate = (DateTime)p[0]; var daysRequired = (int)p[1]; - if (daysRequired == 0) return startDate; + if (daysRequired == 0) + { + return startDate; + } var bankHolidays = new List(); if (p.Count == 3) @@ -362,9 +412,13 @@ private static object Workday(List p) var testDate = startDate.AddDays(((daysRequired / 7) + 2) * 7 * Math.Sign(daysRequired)); var return_date = Workday(startDate, testDate, daysRequired, bankHolidays); if (Math.Sign(daysRequired) == 1) + { return_date = return_date.NextWorkday(bankHolidays); + } else + { return_date = return_date.PreviousWorkDay(bankHolidays); + } return return_date; } @@ -373,9 +427,11 @@ private static DateTime Workday(DateTime startDate, DateTime testDate, int daysR { var businessDays = BusinessDaysUntil(startDate, testDate, bankHolidays); if (businessDays == daysRequired) + { return testDate; + } - int days = businessDays > daysRequired ? -1 : 1; + var days = businessDays > daysRequired ? -1 : 1; return Workday(startDate, testDate.AddDays(days), daysRequired, bankHolidays); } @@ -394,15 +450,26 @@ private static object Yearfrac(List p) var option = p.Count == 3 ? (int)p[2] : 0; if (option == 0) + { return Days360(date1, date2, false) / 360.0; + } + if (option == 1) + { return Math.Floor((date2 - date1).TotalDays) / GetYearAverage(date1, date2); + } + if (option == 2) + { return Math.Floor((date2 - date1).TotalDays) / 360.0; + } + if (option == 3) + { return Math.Floor((date2 - date1).TotalDays) / 365.0; + } return Days360(date1, date2, true) / 360.0; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/Functions/Information.cs b/ClosedXML/Excel/CalcEngine/Functions/Information.cs index be8b7bc00..cbfdd7941 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Information.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Information.cs @@ -27,7 +27,7 @@ public static void Register(CalcEngine ce) ce.RegisterFunction("TYPE", 1, Type); } - static IDictionary errorTypes = new Dictionary() + static readonly IDictionary errorTypes = new Dictionary() { [ErrorExpression.ExpressionErrorType.NullValue] = 1, [ErrorExpression.ExpressionErrorType.DivisionByZero] = 2, @@ -43,9 +43,13 @@ static object ErrorType(List p) var v = p[0].Evaluate(); if (v is ErrorExpression.ExpressionErrorType) + { return errorTypes[(ErrorExpression.ExpressionErrorType)v]; + } else + { throw new NoValueAvailableException(); + } } static object IsBlank(List p) @@ -130,7 +134,7 @@ static object IsNumber(List p) try { var stringValue = (string) v; - return double.TryParse(stringValue.TrimEnd('%', ' '), NumberStyles.Any, null, out double dv); + return double.TryParse(stringValue.TrimEnd('%', ' '), NumberStyles.Any, null, out var dv); } catch (Exception) { @@ -154,13 +158,12 @@ static object IsOdd(List p) static object IsRef(List p) { - var oe = p[0] as XObjectExpression; - if (oe == null) + if (!(p[0] is XObjectExpression oe)) + { return false; + } - var crr = oe.Value as CellRangeReference; - - return crr != null; + return oe.Value is CellRangeReference crr; } static object IsText(List p) diff --git a/ClosedXML/Excel/CalcEngine/Functions/Logical.cs b/ClosedXML/Excel/CalcEngine/Functions/Logical.cs index d5fa41817..ef91419f0 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Logical.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Logical.cs @@ -50,11 +50,18 @@ static object If(List p) else if (p.Count > 2) { if (p[2] is EmptyValueExpression) + { return false; + } else + { return p[2].Evaluate(); + } + } + else + { + return false; } - else return false; } static object True(List p) diff --git a/ClosedXML/Excel/CalcEngine/Functions/Lookup.cs b/ClosedXML/Excel/CalcEngine/Functions/Lookup.cs index 1b9937ae6..3015948ad 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Lookup.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Lookup.cs @@ -34,10 +34,14 @@ public static void Register(CalcEngine ce) private static IXLRange ExtractRange(Expression expression) { if (!(expression is XObjectExpression objectExpression)) + { throw new NoValueAvailableException("Parameter has to be a valid range"); + } if (!(objectExpression.Value is CellRangeReference cellRangeReference)) + { throw new NoValueAvailableException("lookup_array has to be a range"); + } var range = cellRangeReference.Range; return range; @@ -50,13 +54,17 @@ private static object Hlookup(List p) var row_index_num = (int)p[2]; var range_lookup = p.Count < 4 || p[3] is EmptyValueExpression - || (bool)(p[3]); + || (bool)p[3]; if (row_index_num < 1) + { throw new CellReferenceException("Row index has to be positive"); + } if (row_index_num > range.RowCount()) + { throw new CellReferenceException("Row index has to be positive"); + } IXLRangeColumn matching_column; matching_column = range.FindColumn(c => !c.Cell(1).IsEmpty() && new Expression(c.Cell(1).Value).CompareTo(lookup_value) == 0); @@ -69,16 +77,24 @@ private static object Hlookup(List p) { var column_index_in_range = c.ColumnNumber() - first_column + 1; if (column_index_in_range < number_of_columns_in_range && !c.Cell(1).IsEmpty() && new Expression(c.Cell(1).Value).CompareTo(lookup_value) <= 0 && !c.ColumnRight().Cell(1).IsEmpty() && new Expression(c.ColumnRight().Cell(1).Value).CompareTo(lookup_value) > 0) + { return true; + } else if (column_index_in_range == number_of_columns_in_range && !c.Cell(1).IsEmpty() && new Expression(c.Cell(1).Value).CompareTo(lookup_value) <= 0) + { return true; + } else + { return false; + } }); } if (matching_column == null) + { throw new NoValueAvailableException("No matches found."); + } return matching_column .Cell(row_index_num) @@ -87,8 +103,8 @@ private static object Hlookup(List p) private static object Hyperlink(List p) { - String address = p[0]; - String toolTip = p.Count == 2 ? p[1] : String.Empty; + string address = p[0]; + var toolTip = p.Count == 2 ? p[1] : string.Empty; return new XLHyperlink(address, toolTip); } @@ -103,10 +119,14 @@ private static object Index(List p) var column_num = (int)p[2]; if (row_num > range.RowCount()) + { throw new CellReferenceException("Out of bound row number"); + } if (column_num > range.ColumnCount()) + { throw new CellReferenceException("Out of bound column number"); + } return range.Row(row_num).Cell(column_num).Value; } @@ -114,33 +134,47 @@ private static object Index(List p) { var cellOffset = (int)p[1]; if (cellOffset > range.RowCount() * range.ColumnCount()) + { throw new CellReferenceException(); + } return range.Cells().ElementAt(cellOffset - 1).Value; } else { - int column_num = 1; - int row_num = 1; + var column_num = 1; + var row_num = 1; if (!(p[1] is EmptyValueExpression)) + { row_num = (int)p[1]; + } if (!(p[2] is EmptyValueExpression)) + { column_num = (int)p[2]; + } var rangeIsRow = range.RowCount() == 1; if (rangeIsRow && row_num > 1) + { throw new CellReferenceException(); + } if (!rangeIsRow && column_num > 1) + { throw new CellReferenceException(); + } if (row_num > range.RowCount()) + { throw new CellReferenceException("Out of bound row number"); + } if (column_num > range.ColumnCount()) + { throw new CellReferenceException("Out of bound column number"); + } return range.Row(row_num).Cell(column_num).Value; } @@ -150,12 +184,16 @@ private static object Match(List p) { var lookup_value = p[0]; var range = ExtractRange(p[1]); - int match_type = 1; + var match_type = 1; if (p.Count > 2) + { match_type = Math.Sign((int)p[2]); + } if (range.ColumnCount() != 1 && range.RowCount() != 1) + { throw new CellValueException("Range has to be 1-dimensional"); + } Predicate lookupPredicate = null; switch (match_type) @@ -179,9 +217,11 @@ private static object Match(List p) IXLCell foundCell = null; if (match_type == 0) + { foundCell = range .CellsUsed(XLCellsUsedOptions.Contents, c => lookupPredicate.Invoke(new Expression(c.Value).CompareTo(lookup_value))) .FirstOrDefault(); + } else { object previousValue = null; @@ -196,7 +236,9 @@ private static object Match(List p) // When match_type != 0, we have to assume that the order of the items being search is ascending or descending var previousValueExpression = new Expression(previousValue); if (!lookupPredicate.Invoke(previousValueExpression.CompareTo(currentCellExpression))) + { return false; + } } previousValue = c.Value; @@ -207,7 +249,9 @@ private static object Match(List p) } if (foundCell == null) + { throw new NoValueAvailableException(); + } var firstCell = range.FirstCell(); @@ -221,13 +265,17 @@ private static object Vlookup(List p) var col_index_num = (int)p[2]; var range_lookup = p.Count < 4 || p[3] is EmptyValueExpression - || (bool)(p[3]); + || (bool)p[3]; if (col_index_num < 1) + { throw new CellReferenceException("Column index has to be positive"); + } if (col_index_num > range.ColumnCount()) + { throw new CellReferenceException("Colum index must be smaller or equal to the number of columns in the table array"); + } IXLRangeRow matching_row; try @@ -247,16 +295,24 @@ private static object Vlookup(List p) { var row_index_in_range = r.RowNumber() - first_row + 1; if (row_index_in_range < number_of_rows_in_range && !r.Cell(1).IsEmpty() && new Expression(r.Cell(1).Value).CompareTo(lookup_value) <= 0 && !r.RowBelow().Cell(1).IsEmpty() && new Expression(r.RowBelow().Cell(1).Value).CompareTo(lookup_value) > 0) + { return true; + } else if (row_index_in_range == number_of_rows_in_range && !r.Cell(1).IsEmpty() && new Expression(r.Cell(1).Value).CompareTo(lookup_value) <= 0) + { return true; + } else + { return false; + } }); } if (matching_row == null) + { throw new NoValueAvailableException("No matches found."); + } return matching_row .Cell(col_index_num) diff --git a/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs b/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs index 7e6dd81c0..cc67c7f09 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/MathTrig.cs @@ -1,12 +1,11 @@ using ClosedXML.Excel.CalcEngine.Exceptions; -using ClosedXML.Excel.CalcEngine.Functions; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; -namespace ClosedXML.Excel.CalcEngine +namespace ClosedXML.Excel.CalcEngine.Functions { internal static class MathTrig { @@ -36,7 +35,7 @@ public static void Register(CalcEngine ce) ce.RegisterFunction("COTH", 1, Coth); ce.RegisterFunction("CSC", 1, Csc); ce.RegisterFunction("CSCH", 1, Csch); - ce.RegisterFunction("DECIMAL", 2, MathTrig.Decimal); + ce.RegisterFunction("DECIMAL", 2, Decimal); ce.RegisterFunction("DEGREES", 1, Degrees); ce.RegisterFunction("EVEN", 1, Even); ce.RegisterFunction("EXP", 1, Exp); @@ -99,7 +98,9 @@ private static object Acos(List p) { double input = p[0]; if (Math.Abs(input) > 1) + { throw new NumberException(); + } return Math.Acos(p[0]); } @@ -108,7 +109,9 @@ private static object Asin(List p) { double input = p[0]; if (Math.Abs(input) > 1) + { throw new NumberException(); + } return Math.Asin(input); } @@ -123,7 +126,9 @@ private static object Atan2(List p) double x = p[0]; double y = p[1]; if (x == 0 && y == 0) + { throw new DivisionByZeroException(); + } return Math.Atan2(y, x); } @@ -134,32 +139,54 @@ private static object Ceiling(List p) double significance = p[1]; if (significance == 0) + { return 0d; + } else if (significance < 0 && number > 0) + { throw new NumberException(); + } else if (significance < 0) + { return -Math.Ceiling(-number / -significance) * -significance; + } else + { return Math.Ceiling(number / significance) * significance; + } } private static object CeilingMath(List p) { double number = p[0]; double significance = 1; - if (p.Count > 1) significance = p[1]; + if (p.Count > 1) + { + significance = p[1]; + } double mode = 0; - if (p.Count > 2) mode = p[2]; + if (p.Count > 2) + { + mode = p[2]; + } if (significance == 0) + { return 0d; + } else if (number >= 0) + { return Math.Ceiling(number / Math.Abs(significance)) * Math.Abs(significance); + } else if (mode == 0) + { return Math.Ceiling(number / Math.Abs(significance)) * Math.Abs(significance); + } else + { return -Math.Ceiling(-number / Math.Abs(significance)) * Math.Abs(significance); + } } private static object Cos(List p) @@ -177,7 +204,9 @@ private static object Cot(List p) var tan = (double)Math.Tan(p[0]); if (tan == 0) + { throw new DivisionByZeroException(); + } return 1 / tan; } @@ -186,7 +215,9 @@ private static object Coth(List p) { double input = p[0]; if (input == 0) + { throw new DivisionByZeroException(); + } return 1 / Math.Tanh(input); } @@ -195,15 +226,19 @@ private static object Csc(List p) { double input = p[0]; if (input == 0) + { throw new DivisionByZeroException(); + } return 1 / Math.Sin(input); } private static object Csch(List p) { - if (Math.Abs((double)p[0].Evaluate()) < Double.Epsilon) + if (Math.Abs((double)p[0].Evaluate()) < double.Epsilon) + { throw new DivisionByZeroException(); + } return 1 / Math.Sinh(p[0]); } @@ -214,26 +249,30 @@ private static object Decimal(List p) double radix = p[1]; if (radix < 2 || radix > 36) + { throw new NumberException(); + } var asciiValues = Encoding.ASCII.GetBytes(source.ToUpperInvariant()); double result = 0; - int i = 0; + var i = 0; - foreach (byte digit in asciiValues) + foreach (var digit in asciiValues) { if (digit > 90) { throw new NumberException(); } - int digitNumber = digit >= 48 && digit < 58 + var digitNumber = digit >= 48 && digit < 58 ? digit - 48 : digit - 55; if (digitNumber > radix - 1) + { throw new NumberException(); + } result = result * radix + digitNumber; i++; @@ -253,32 +292,54 @@ private static object Floor(List p) double significance = p[1]; if (significance == 0) + { throw new DivisionByZeroException(); + } else if (significance < 0 && number > 0) + { throw new NumberException(); + } else if (significance < 0) + { return -Math.Floor(-number / -significance) * -significance; + } else + { return Math.Floor(number / significance) * significance; + } } private static object FloorMath(List p) { double number = p[0]; double significance = 1; - if (p.Count > 1) significance = p[1]; + if (p.Count > 1) + { + significance = p[1]; + } double mode = 0; - if (p.Count > 2) mode = p[2]; + if (p.Count > 2) + { + mode = p[2]; + } if (significance == 0) + { return 0d; + } else if (number >= 0) + { return Math.Floor(number / Math.Abs(significance)) * Math.Abs(significance); + } else if (mode == 0) + { return Math.Floor(number / Math.Abs(significance)) * Math.Abs(significance); + } else + { return -Math.Floor(-number / Math.Abs(significance)) * Math.Abs(significance); + } } private static object Int(List p) @@ -395,19 +456,19 @@ private static object SumIfs(List p) var ce = new CalcEngine(); var tally = new Tally(); - int numberOfCriteria = p.Count / 2; // int division returns floor() automatically, that's what we want. + var numberOfCriteria = p.Count / 2; // int division returns floor() automatically, that's what we want. // prepare criteria-parameters: var criteriaRanges = new Tuple>[numberOfCriteria]; - for (int criteriaPair = 0; criteriaPair < numberOfCriteria; criteriaPair++) + for (var criteriaPair = 0; criteriaPair < numberOfCriteria; criteriaPair++) { - var criteriaRange = p[criteriaPair * 2 + 1] as IEnumerable; - - if (criteriaRange == null) + if (!(p[criteriaPair * 2 + 1] is IEnumerable criteriaRange)) + { throw new CellReferenceException($"Expected parameter {criteriaPair * 2 + 2} to be a range"); + } var criterion = p[criteriaPair * 2 + 2].Evaluate(); - var criteriaRangeValues = criteriaRange.Cast().ToList(); + var criteriaRangeValues = criteriaRange.Cast().ToList(); criteriaRanges[criteriaPair] = new Tuple>( criterion, @@ -416,7 +477,7 @@ private static object SumIfs(List p) for (var i = 0; i < sumRangeValues.Count; i++) { - bool shouldUseValue = true; + var shouldUseValue = true; foreach (var criteriaPair in criteriaRanges) { @@ -431,7 +492,9 @@ private static object SumIfs(List p) } if (shouldUseValue) + { tally.AddValue(sumRangeValues[i]); + } } // done @@ -442,20 +505,27 @@ private static object SumProduct(List p) { // all parameters should be IEnumerable if (p.Any(param => !(param is IEnumerable))) + { throw new NoValueAvailableException(); + } var counts = p.Cast().Select(param => { - int i = 0; + var i = 0; foreach (var item in param) + { i++; + } + return i; }) .Distinct(); // All parameters should have the same length if (counts.Count() > 1) + { throw new NoValueAvailableException(); + } var values = p .Cast() @@ -465,9 +535,13 @@ private static object SumProduct(List p) foreach (var c in range) { if (c.IsNumber()) + { results.Add(c.CastTo()); + } else + { results.Add(0.0); + } } return results; }) @@ -497,66 +571,72 @@ private static object Trunc(List p) var num_digits = 0d; if (p.Count > 1) + { num_digits = (double)p[1]; + } var scaling = Math.Pow(10, num_digits); var truncated = (int)(number * scaling); - return (double)truncated / scaling; + return truncated / scaling; } public static double DegreesToRadians(double degrees) { - return (Math.PI / 180.0) * degrees; + return Math.PI / 180.0 * degrees; } public static double RadiansToDegrees(double radians) { - return (180.0 / Math.PI) * radians; + return 180.0 / Math.PI * radians; } public static double GradsToRadians(double grads) { - return (grads / 200.0) * Math.PI; + return grads / 200.0 * Math.PI; } public static double RadiansToGrads(double radians) { - return (radians / Math.PI) * 200.0; + return radians / Math.PI * 200.0; } public static double DegreesToGrads(double degrees) { - return (degrees / 9.0) * 10.0; + return degrees / 9.0 * 10.0; } public static double GradsToDegrees(double grads) { - return (grads / 10.0) * 9.0; + return grads / 10.0 * 9.0; } public static double ASinh(double x) { - return (Math.Log(x + Math.Sqrt(x * x + 1.0))); + return Math.Log(x + Math.Sqrt(x * x + 1.0)); } private static object Acosh(List p) { double number = p[0]; if (number < 1) + { throw new NumberException(); + } return XLMath.ACosh(p[0]); } private static object Acot(List p) { - double x = Math.Atan(1.0 / p[0]); + var x = Math.Atan(1.0 / p[0]); // Acot in Excel calculates the modulus of the function above. // as the % operator is not the modulus, but the remainder, we have to calculate the modulus by hand: while (x < 0) + { x = x + Math.PI; + } return x; } @@ -565,25 +645,36 @@ private static object Acoth(List p) { double number = p[0]; if (Math.Abs(number) < 1) + { throw new NumberException(); + } return 0.5 * Math.Log((number + 1) / (number - 1)); } private static object Arabic(List p) { - string input = ((string)p[0]).Trim(); + var input = ((string)p[0]).Trim(); try { if (input.Length == 0) + { return 0; + } + if (input == "-") + { throw new NumberException(); + } else if (input[0] == '-') + { return -XLMath.RomanToArabic(input.Substring(1)); + } else + { return XLMath.RomanToArabic(input); + } } catch (ArgumentOutOfRangeException) { @@ -604,7 +695,9 @@ private static object Atanh(List p) { double input = p[0]; if (Math.Abs(input) >= 1) + { throw new NumberException(); + } return XLMath.ATanh(p[0]); } @@ -613,73 +706,102 @@ private static object Base(List p) { long number; int radix; - int minLength = 0; + var minLength = 0; var rawNumber = p[0].Evaluate(); if (rawNumber is long || rawNumber is int || rawNumber is byte || rawNumber is double || rawNumber is float) + { number = Convert.ToInt64(rawNumber); + } else + { throw new CellValueException(); + } var rawRadix = p[1].Evaluate(); if (rawRadix is long || rawRadix is int || rawRadix is byte || rawRadix is double || rawRadix is float) + { radix = Convert.ToInt32(rawRadix); + } else + { throw new CellValueException(); + } if (p.Count > 2) { var rawMinLength = p[2].Evaluate(); if (rawMinLength is long || rawMinLength is int || rawMinLength is byte || rawMinLength is double || rawMinLength is float) + { minLength = Convert.ToInt32(rawMinLength); + } else + { throw new CellValueException(); + } } if (number < 0 || radix < 2 || radix > 36) + { throw new NumberException(); + } return XLMath.ChangeBase(number, radix).PadLeft(minLength, '0'); } private static object Combin(List p) { - Int32 n; - Int32 k; + int n; + int k; var rawN = p[0].Evaluate(); var rawK = p[1].Evaluate(); if (rawN is long || rawN is int || rawN is byte || rawN is double || rawN is float) + { n = (int)Math.Floor((double)rawN); + } else + { throw new NumberException(); + } if (rawK is long || rawK is int || rawK is byte || rawK is double || rawK is float) + { k = (int)Math.Floor((double)rawK); + } else + { throw new NumberException(); + } n = (int)p[0]; k = (int)p[1]; if (n < 0 || n < k || k < 0) + { throw new NumberException(); + } return XLMath.Combin(n, k); } private static object CombinA(List p) { - Int32 number = (int)p[0]; // casting truncates towards 0 as specified - Int32 chosen = (int)p[1]; + var number = (int)p[0]; // casting truncates towards 0 as specified + var chosen = (int)p[1]; if (number < 0 || number < chosen) + { throw new NumberException(); + } + if (chosen < 0) + { throw new NumberException(); + } - int n = number + chosen - 1; - int k = number - 1; + var n = number + chosen - 1; + var k = number - 1; return n == k || k == 0 ? 1 @@ -696,17 +818,26 @@ private static object Fact(List p) var input = p[0].Evaluate(); if (!(input is long || input is int || input is byte || input is double || input is float)) + { throw new CellValueException(); + } var num = Math.Floor((double)input); - double fact = 1.0; + var fact = 1.0; if (num < 0) + { throw new NumberException(); + } if (num > 1) - for (int i = 2; i <= num; i++) + { + for (var i = 2; i <= num; i++) + { fact *= i; + } + } + return fact; } @@ -715,19 +846,25 @@ private static object FactDouble(List p) var input = p[0].Evaluate(); if (!(input is long || input is int || input is byte || input is double || input is float)) + { throw new CellValueException(); + } var num = Math.Floor(p[0]); - double fact = 1.0; + var fact = 1.0; if (num < -1) + { throw new NumberException(); + } if (num > 1) { var start = Math.Abs(num % 2) < XLHelper.Epsilon ? 2 : 1; - for (int i = start; i <= num; i = i + 2) + for (var i = start; i <= num; i = i + 2) + { fact *= i; + } } return fact; } @@ -749,7 +886,11 @@ private static object Lcm(List p) private static int Lcm(int a, int b) { - if (a == 0 || b == 0) return 0; + if (a == 0 || b == 0) + { + return 0; + } + return a * (b / Gcd(a, b)); } @@ -763,11 +904,13 @@ private static object Mod(List p) private static object MRound(List p) { - var number = (Double)p[0]; - var multiple = (Double)p[1]; + var number = (double)p[0]; + var multiple = (double)p[1]; if (Math.Sign(number) != Math.Sign(multiple)) + { throw new NumberException($"The Number and Multiple arguments must have the same sign."); + } return Math.Round(number / multiple, MidpointRounding.AwayFromZero) * multiple; } @@ -781,20 +924,29 @@ private static double Multinomial(List numbers) { double numbersSum = 0; foreach (var number in numbers) + { numbersSum += number; + } - double maxNumber = numbers.Max(); + var maxNumber = numbers.Max(); var denomFactorPowers = new double[(uint)numbers.Max() + 1]; foreach (var number in numbers) - for (int i = 2; i <= number; i++) + { + for (var i = 2; i <= number; i++) + { denomFactorPowers[i]++; - for (int i = 2; i < denomFactorPowers.Length; i++) + } + } + + for (var i = 2; i < denomFactorPowers.Length; i++) + { denomFactorPowers[i]--; // reduce with nominator; + } - int currentFactor = 2; + var currentFactor = 2; double currentPower = 1; double result = 1; - for (double i = maxNumber + 1; i <= numbersSum; i++) + for (var i = maxNumber + 1; i <= numbersSum; i++) { double tempDenom = 1; while (tempDenom < result && currentFactor < denomFactorPowers.Length) @@ -832,16 +984,20 @@ private static object Even(List p) private static object Product(List p) { - if (p.Count == 0) return 0; - Double total = 1; + if (p.Count == 0) + { + return 0; + } + + double total = 1; p.ForEach(v => total *= v); return total; } private static object Quotient(List p) { - Double n = p[0]; - Double k = p[1]; + double n = p[0]; + double k = p[1]; return (int)(n / k); } @@ -854,17 +1010,19 @@ private static object Radians(List p) private static object Roman(List p) { if (p.Count == 1 - || (Boolean.TryParse(p[1]._token.Value.ToString(), out bool boolTemp) && boolTemp) - || (Int32.TryParse(p[1]._token.Value.ToString(), out int intTemp) && intTemp == 1)) + || bool.TryParse(p[1]._token.Value.ToString(), out var boolTemp) && boolTemp + || int.TryParse(p[1]._token.Value.ToString(), out var intTemp) && intTemp == 1) + { return XLMath.ToRoman((int)p[0]); + } throw new ArgumentException("Can only support classic roman types."); } private static object Round(List p) { - var value = (Double)p[0]; - var digits = (Int32)(Double)p[1]; + var value = (double)p[0]; + var digits = (int)(double)p[1]; if (digits >= 0) { return Math.Round(value, digits, MidpointRounding.AwayFromZero); @@ -872,7 +1030,7 @@ private static object Round(List p) else { digits = Math.Abs(digits); - double temp = value / Math.Pow(10, digits); + var temp = value / Math.Pow(10, digits); temp = Math.Round(temp, 0, MidpointRounding.AwayFromZero); return temp * Math.Pow(10, digits); } @@ -880,32 +1038,40 @@ private static object Round(List p) private static object RoundDown(List p) { - var value = (Double)p[0]; - var digits = (Int32)(Double)p[1]; + var value = (double)p[0]; + var digits = (int)(double)p[1]; if (value >= 0) + { return Math.Floor(value * Math.Pow(10, digits)) / Math.Pow(10, digits); + } return Math.Ceiling(value * Math.Pow(10, digits)) / Math.Pow(10, digits); } private static object RoundUp(List p) { - var value = (Double)p[0]; - var digits = (Int32)(Double)p[1]; + var value = (double)p[0]; + var digits = (int)(double)p[1]; if (value >= 0) + { return Math.Ceiling(value * Math.Pow(10, digits)) / Math.Pow(10, digits); + } return Math.Floor(value * Math.Pow(10, digits)) / Math.Pow(10, digits); } private static object Sec(List p) { - if (double.TryParse(p[0], out double number)) + if (double.TryParse(p[0], out var number)) + { return 1.0 / Math.Cos(number); + } else + { throw new CellValueException(); + } } private static object Sech(List p) @@ -915,16 +1081,17 @@ private static object Sech(List p) private static object SeriesSum(List p) { - var x = (Double)p[0]; - var n = (Double)p[1]; - var m = (Double)p[2]; - var obj = p[3] as XObjectExpression; + var x = (double)p[0]; + var n = (double)p[1]; + var m = (double)p[2]; - if (obj == null) + if (!(p[3] is XObjectExpression obj)) + { return p[3] * Math.Pow(x, n); + } - Double total = 0; - Int32 i = 0; + double total = 0; + var i = 0; foreach (var e in obj) { total += (double)e * Math.Pow(x, n + i * m); @@ -936,7 +1103,7 @@ private static object SeriesSum(List p) private static object SqrtPi(List p) { - var num = (Double)p[0]; + var num = (double)p[0]; return Math.Sqrt(Math.PI * num); } @@ -946,13 +1113,19 @@ private static object Subtotal(List p) bool hasSubtotalInFormula(Expression e) { if (e is FunctionExpression fe && (fe.FunctionDefinition.Function.Method.Name == nameof(Subtotal) || fe.Parameters.Any(fp => hasSubtotalInFormula(fp)))) + { return true; + } if (e is BinaryExpression be) + { return hasSubtotalInFormula(be.LeftExpression) || hasSubtotalInFormula(be.RightExpression); + } if (e is UnaryExpression ue) + { return hasSubtotalInFormula(ue.Expression); + } return false; }; @@ -971,7 +1144,9 @@ IEnumerable extractExpressionsWithoutSubtotal(CellRangeReference crr return !hasSubtotalInFormula(expression); } else + { return true; + } }) .Select(c => new XObjectExpression(new CellRangeReference(c.AsRange(), (XLCalcEngine)crr.CalcEngine)) as Expression); }; @@ -983,7 +1158,7 @@ e is XObjectExpression xoe && xoe.Value is CellRangeReference crr : new[] { e }) .ToArray(); - var fId = (int)(Double)p[0]; + var fId = (int)(double)p[0]; var tally = new Tally(expressions); switch (fId) @@ -1034,18 +1209,20 @@ private static object SumSq(List p) private static object MMult(List p) { - Double[,] A = GetArray(p[0]); - Double[,] B = GetArray(p[1]); + var A = GetArray(p[0]); + var B = GetArray(p[1]); if (A.GetLength(0) != B.GetLength(0) || A.GetLength(1) != B.GetLength(1)) + { throw new ArgumentException("Ranges must have the same number of rows and columns."); + } var C = new double[A.GetLength(0), A.GetLength(1)]; - for (int i = 0; i < A.GetLength(0); i++) + for (var i = 0; i < A.GetLength(0); i++) { - for (int j = 0; j < B.GetLength(1); j++) + for (var j = 0; j < B.GetLength(1); j++) { - for (int k = 0; k < A.GetLength(1); k++) + for (var k = 0; k < A.GetLength(1); k++) { C[i, j] += A[i, k] * B[k, j]; } @@ -1057,17 +1234,19 @@ private static object MMult(List p) private static double[,] GetArray(Expression expression) { - var oExp1 = expression as XObjectExpression; - if (oExp1 == null) return new[,] { { (Double)expression } }; + if (!(expression is XObjectExpression oExp1)) + { + return new[,] { { (double)expression } }; + } var range = (oExp1.Value as CellRangeReference).Range; var rowCount = range.RowCount(); var columnCount = range.ColumnCount(); var arr = new double[rowCount, columnCount]; - for (int row = 0; row < rowCount; row++) + for (var row = 0; row < rowCount; row++) { - for (int column = 0; column < columnCount; column++) + for (var column = 0; column < columnCount; column++) { arr[row, column] = range.Cell(row + 1, column + 1).GetDouble(); } @@ -1092,4 +1271,4 @@ private static object MInverse(List p) return m.Invert().mat; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/Functions/Statistical.cs b/ClosedXML/Excel/CalcEngine/Functions/Statistical.cs index 1ff9c82f6..a3c0f0caa 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Statistical.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Statistical.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel.CalcEngine.Exceptions; +using ClosedXML.Excel.CalcEngine.Functions; using System; using System.Collections.Generic; using System.Linq; @@ -52,7 +53,7 @@ public static void Register(CalcEngine ce) //LOGNORMDIST Returns the cumulative lognormal distribution ce.RegisterFunction("MAX", 1, int.MaxValue, Max); ce.RegisterFunction("MAXA", 1, int.MaxValue, MaxA); - //MEDIAN Returns the median of the given numbers + ce.RegisterFunction("MEDIAN", 1, int.MaxValue, Median); ce.RegisterFunction("MIN", 1, int.MaxValue, Min); ce.RegisterFunction("MINA", 1, int.MaxValue, MinA); //MODE Returns the most common value in a data set @@ -119,15 +120,19 @@ private static object CountA(List p) private static object CountBlank(List p) { if ((p[0] as XObjectExpression)?.Value as CellRangeReference == null) + { throw new NoValueAvailableException("COUNTBLANK should have a single argument which is a range reference"); + } var e = p[0] as XObjectExpression; - long totalCount = CalcEngineHelpers.GetTotalCellsCount(e); + var totalCount = CalcEngineHelpers.GetTotalCellsCount(e); long nonBlankCount = 0; foreach (var value in e) { if (!CalcEngineHelpers.ValueIsBlank(value)) + { nonBlankCount++; + } } return 0d + totalCount - nonBlankCount; @@ -135,23 +140,28 @@ private static object CountBlank(List p) private static object CountIf(List p) { - CalcEngine ce = new CalcEngine(); + var ce = new CalcEngine(); var cnt = 0.0; long processedCount = 0; if (p[0] is XObjectExpression ienum) { - long totalCount = CalcEngineHelpers.GetTotalCellsCount(ienum); + var totalCount = CalcEngineHelpers.GetTotalCellsCount(ienum); var criteria = p[1].Evaluate(); foreach (var value in ienum) { if (CalcEngineHelpers.ValueSatisfiesCriteria(value, criteria, ce)) + { cnt++; + } + processedCount++; } // Add count of empty cells outside the used range if they match criteria if (CalcEngineHelpers.ValueSatisfiesCriteria(string.Empty, criteria, ce)) - cnt += (totalCount - processedCount); + { + cnt += totalCount - processedCount; + } } return cnt; @@ -163,12 +173,12 @@ private static object CountIfs(List p) var ce = new CalcEngine(); long count = 0; - int numberOfCriteria = p.Count / 2; + var numberOfCriteria = p.Count / 2; long totalCount = 0; // prepare criteria-parameters: var criteriaRanges = new Tuple>[numberOfCriteria]; - for (int criteriaPair = 0; criteriaPair < numberOfCriteria; criteriaPair++) + for (var criteriaPair = 0; criteriaPair < numberOfCriteria; criteriaPair++) { var criteriaRange = p[criteriaPair * 2] as XObjectExpression; var criterion = p[(criteriaPair * 2) + 1].Evaluate(); @@ -183,7 +193,9 @@ private static object CountIfs(List p) criteriaRangeValues); if (totalCount == 0) + { totalCount = CalcEngineHelpers.GetTotalCellsCount(criteriaRange); + } } long processedCount = 0; @@ -191,7 +203,9 @@ private static object CountIfs(List p) { if (criteriaRanges.All(criteriaPair => CalcEngineHelpers.ValueSatisfiesCriteria( criteriaPair.Item2[i], criteriaPair.Item1, ce))) + { count++; + } processedCount++; } @@ -200,7 +214,7 @@ private static object CountIfs(List p) if (criteriaRanges.All(criteriaPair => CalcEngineHelpers.ValueSatisfiesCriteria( string.Empty, criteriaPair.Item1, ce))) { - count += (totalCount - processedCount); + count += totalCount - processedCount; } // done @@ -215,7 +229,10 @@ private static object DevSq(List p) private static object Fisher(List p) { var x = (double)p[0]; - if (x <= -1 || x >= 1) throw new NumberException("Incorrect value. Should be: -1 > x < 1."); + if (x <= -1 || x >= 1) + { + throw new NumberException("Incorrect value. Should be: -1 > x < 1."); + } return 0.5 * Math.Log((1 + x) / (1 - x)); } @@ -235,6 +252,11 @@ private static object MaxA(List p) return GetTally(p, false).Max(); } + private static object Median(List p) + { + return GetTally(p, false).Median(); + } + private static object Min(List p) { return GetTally(p, true).Min(); diff --git a/ClosedXML/Excel/CalcEngine/Functions/Tally.cs b/ClosedXML/Excel/CalcEngine/Functions/Tally.cs index d5141931d..e8b5d747c 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Tally.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Tally.cs @@ -6,9 +6,9 @@ using System.Linq; using System.Threading; -namespace ClosedXML.Excel.CalcEngine +namespace ClosedXML.Excel.CalcEngine.Functions { - internal class Tally : IEnumerable + internal class Tally : IEnumerable { private readonly List _list = new List(); private readonly bool NumbersOnly; @@ -56,24 +56,61 @@ public void Add(Expression e) // handle expressions var val = e.Evaluate(); if (val is string || !(val is IEnumerable valEnumerable)) + { _list.Add(val); + } else + { foreach (var v in valEnumerable) + { _list.Add(v); + } + } _numericValues = null; } - public void AddValue(Object v) + public void AddValue(object v) { _list.Add(v); _numericValues = null; } + public double Median() + { + var nums = NumericValuesInternal() + .OrderBy(n => n) + .ToArray(); + + if (nums.Length == 0) + { + throw new ApplicationException("No values"); + } + + var hasEvenCount = nums.Length % 2 == 0; + + if (hasEvenCount) + { + var numElementsToSkip = nums.Length / 2 - 1; + + return nums.Skip(numElementsToSkip) + .Take(2) + .Average(); + } + + var medianIndex = (nums.Length - 1) / 2; + + return nums[medianIndex]; + } + public double Average() { var nums = NumericValuesInternal(); - if (nums.Length == 0) throw new ApplicationException("No values"); + if (nums.Length == 0) + { + throw new ApplicationException("No values"); + } + return nums.Average(); } @@ -85,15 +122,22 @@ public double Count() public double Count(bool numbersOnly) { if (numbersOnly) + { return NumericValuesInternal().Length; + } else + { return _list.Count(o => !CalcEngineHelpers.ValueIsBlank(o)); + } } public double DevSq() { var nums = NumericValuesInternal(); - if (nums.Length == 0) throw new CellValueException("No numeric parameters."); + if (nums.Length == 0) + { + throw new CellValueException("No numeric parameters."); + } return nums.Sum(x => Math.Pow(x - Average(), 2)); } @@ -102,8 +146,15 @@ public double Geomean() { var nums = NumericValuesInternal(); - if (nums.Length == 0) throw new NumberException("No numeric parameters."); - if (HasNonPositiveNumbers()) throw new NumberException("Incorrect parameters. Use only positive numbers in your data."); + if (nums.Length == 0) + { + throw new NumberException("No numeric parameters."); + } + + if (HasNonPositiveNumbers()) + { + throw new NumberException("Incorrect parameters. Use only positive numbers in your data."); + } return Math.Pow(Product(), 1.0 / nums.Length); } @@ -151,11 +202,11 @@ public double Std() if (count != 0) { //Compute the Average - double avg = values.Average(); + var avg = values.Average(); //Perform the Sum of (value-avg)_2_2 - double sum = values.Sum(d => Math.Pow(d - avg, 2)); + var sum = values.Sum(d => Math.Pow(d - avg, 2)); //Put it all together - ret = Math.Sqrt((sum) / (count - 1)); + ret = Math.Sqrt(sum / (count - 1)); } else { @@ -210,15 +261,19 @@ private IEnumerable NumericValuesEnumerable() { if (value is string || !(value is IEnumerable vEnumerable)) { - if (TryParseToDouble(value, aggressiveConversion: false, out double tmp)) + if (TryParseToDouble(value, aggressiveConversion: false, out var tmp)) + { yield return tmp; + } } else { foreach (var v in vEnumerable) { - if (TryParseToDouble(v, aggressiveConversion: false, out double tmp)) + if (TryParseToDouble(v, aggressiveConversion: false, out var tmp)) + { yield return tmp; + } } } } @@ -236,11 +291,14 @@ private bool TryParseToDouble(object value, bool aggressiveConversion, out doubl d = Convert.ToDouble(value); return true; } - else if (value is Boolean b) + else if (value is bool b) { - if (!aggressiveConversion) return false; + if (!aggressiveConversion) + { + return false; + } - d = (b ? 1 : 0); + d = b ? 1 : 0; return true; } else if (value is DateTime dt) @@ -255,11 +313,15 @@ private bool TryParseToDouble(object value, bool aggressiveConversion, out doubl } else if (value is string s) { - if (!aggressiveConversion) return false; + if (!aggressiveConversion) + { + return false; + } + return double.TryParse(s, out d); } return false; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/Functions/Text.cs b/ClosedXML/Excel/CalcEngine/Functions/Text.cs index 13d1a6702..83867d374 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/Text.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/Text.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel.CalcEngine.Exceptions; +using ClosedXML.Excel.Ranges; using ExcelNumberFormat; using System; using System.Collections; @@ -8,7 +9,7 @@ using System.Text; using System.Text.RegularExpressions; -namespace ClosedXML.Excel.CalcEngine +namespace ClosedXML.Excel.CalcEngine.Functions { internal static class Text { @@ -39,7 +40,7 @@ public static void Register(CalcEngine ce) ce.RegisterFunction("SEARCH", 2, 3, Search); // Finds one text value within another (not case-sensitive) ce.RegisterFunction("SUBSTITUTE", 3, 4, Substitute); // Substitutes new text for old text in a text string ce.RegisterFunction("T", 1, T); // Converts its arguments to text - ce.RegisterFunction("TEXT", 2, _Text); // Formats a number and converts it to text + ce.RegisterFunction("TEXT", 2, GetText); // Formats a number and converts it to text ce.RegisterFunction("TEXTJOIN", 3, 254, TextJoin); // Joins text via delimiter ce.RegisterFunction("TRIM", 1, Trim); // Removes spaces from text ce.RegisterFunction("UPPER", 1, Upper); // Converts text to uppercase @@ -50,7 +51,9 @@ private static object _Char(List p) { var i = (int)p[0]; if (i < 1 || i > 255) + { throw new CellValueException(string.Format("The number {0} is out of the required range (1 to 255)", i)); + } var c = (char)i; return c.ToString(); @@ -70,10 +73,14 @@ private static object Concat(List p) if (x is IEnumerable enumerable) { foreach (var i in enumerable) - sb.Append((string)(new Expression(i))); + { + sb.Append((string)new Expression(i)); + } } else + { sb.Append((string)x); + } } return sb.ToString(); } @@ -88,15 +95,21 @@ private static object Concatenate(List p) if (objectExpression.Value is CellRangeReference cellRangeReference) { if (!cellRangeReference.Range.RangeAddress.IsValid) + { throw new CellReferenceException(); + } // Only single cell range references allows at this stage. See unit test for more details if (cellRangeReference.Range.RangeAddress.NumberOfCells > 1) + { throw new CellValueException("This function does not accept cell ranges as parameters."); + } } else + { // I'm unsure about what else objectExpression.Value could be, but let's throw CellReferenceException throw new CellReferenceException(); + } } sb.Append((string)x); @@ -115,9 +128,13 @@ private static object Find(List p) } var index = text.IndexOf(srch, start, StringComparison.Ordinal); if (index == -1) + { throw new ArgumentException("String not found."); + } else + { return index + 1; + } } private static object Left(List p) @@ -128,7 +145,10 @@ private static object Left(List p) { n = (int)p[1]; } - if (n >= str.Length) return str; + if (n >= str.Length) + { + return str; + } return str.Substring(0, n); } @@ -149,9 +169,15 @@ private static object Mid(List p) var start = (int)p[1] - 1; var length = (int)p[2]; if (start > str.Length - 1) - return String.Empty; + { + return string.Empty; + } + if (start + length > str.Length - 1) + { return str.Substring(start); + } + return str.Substring(start, length); } @@ -163,13 +189,14 @@ private static string MatchHandler(Match m) private static object Proper(List p) { var s = (string)p[0]; - if (s.Length == 0) return ""; - - MatchEvaluator evaluator = new MatchEvaluator(MatchHandler); - StringBuilder sb = new StringBuilder(); + if (s.Length == 0) + { + return ""; + } - string pattern = "\\b(\\w)(\\w+)?\\b"; - Regex regex = new Regex(pattern, RegexOptions.Multiline | RegexOptions.IgnoreCase); + var evaluator = new MatchEvaluator(MatchHandler); + var pattern = "\\b(\\w)(\\w+)?\\b"; + var regex = new Regex(pattern, RegexOptions.Multiline | RegexOptions.IgnoreCase); return regex.Replace(s.ToLower(), evaluator); } @@ -181,7 +208,10 @@ private static object Replace(List p) var len = (int)p[2]; var rep = (string)p[3]; - if (s.Length == 0) return rep; + if (s.Length == 0) + { + return rep; + } var sb = new StringBuilder(); sb.Append(s.Substring(0, start)); @@ -196,8 +226,12 @@ private static object Rept(List p) var sb = new StringBuilder(); var s = (string)p[0]; var repeats = (int)p[1]; - if (repeats < 0) throw new IndexOutOfRangeException("repeats"); - for (int i = 0; i < repeats; i++) + if (repeats < 0) + { + throw new ArithmeticException("repeats"); + } + + for (var i = 0; i < repeats; i++) { sb.Append(s); } @@ -213,7 +247,10 @@ private static object Right(List p) n = (int)p[1]; } - if (n >= str.Length) return str; + if (n >= str.Length) + { + return str; + } return str.Substring(str.Length - n); } @@ -231,7 +268,10 @@ private static object Search(List p) var search = WildcardToRegex(p[0]); var text = (string)p[1]; - if ("" == text) throw new ArgumentException("Invalid input string."); + if (string.IsNullOrEmpty(text)) + { + throw new ArgumentException("Invalid input string."); + } var start = 0; if (p.Count > 2) @@ -239,17 +279,16 @@ private static object Search(List p) start = (int)p[2] - 1; } - Regex r = new Regex(search, RegexOptions.Compiled | RegexOptions.IgnoreCase); + var r = new Regex(search, RegexOptions.Compiled | RegexOptions.IgnoreCase); var match = r.Match(text.Substring(start)); if (!match.Success) + { throw new ArgumentException("Search failed."); + } else + { return match.Index + start + 1; - //var index = text.IndexOf(search, start, StringComparison.OrdinalIgnoreCase); - //if (index == -1) - // throw new ArgumentException("String not found."); - //else - // return index + 1; + } } private static object Substitute(List p) @@ -259,8 +298,15 @@ private static object Substitute(List p) var oldText = (string)p[1]; var newText = (string)p[2]; - if ("" == text) return ""; - if ("" == oldText) return text; + if (string.IsNullOrEmpty(text)) + { + return ""; + } + + if (string.IsNullOrEmpty(oldText)) + { + return text; + } // if index not supplied, replace all if (p.Count == 3) @@ -269,12 +315,12 @@ private static object Substitute(List p) } // replace specific instance - int index = (int)p[3]; + var index = (int)p[3]; if (index < 1) { throw new ArgumentException("Invalid index in Substitute."); } - int pos = text.IndexOf(oldText); + var pos = text.IndexOf(oldText, StringComparison.CurrentCulture); while (pos > -1 && index > 1) { pos = text.IndexOf(oldText, pos + 1); @@ -287,29 +333,43 @@ private static object Substitute(List p) private static object T(List p) { - if (p[0]._token.Value.GetType() == typeof(string)) + if (p[0]._token.Value is string) + { return (string)p[0]; + } else + { return ""; + } } - private static object _Text(List p) + private static object GetText(List p) { var value = p[0].Evaluate(); // Input values of type string don't get any formatting applied. - if (value is string) return value; + if (value is string) + { + return value; + } var number = (double)p[0]; var format = (string)p[1]; - if (string.IsNullOrEmpty(format.Trim())) return ""; + if (string.IsNullOrEmpty(format.Trim())) + { + return ""; + } var nf = new NumberFormat(format); if (nf.IsDateTimeFormat) + { return nf.Format(DateTime.FromOADate(number), CultureInfo.InvariantCulture); + } else + { return nf.Format(number, CultureInfo.InvariantCulture); + } } /// @@ -342,18 +402,24 @@ private static object TextJoin(List p) if (param is XObjectExpression tableArray) { if (!(tableArray.Value is CellRangeReference rangeReference)) + { throw new NoValueAvailableException("tableArray has to be a range"); + } var range = rangeReference.Range; IEnumerable cellValues; if (ignoreEmptyStrings) + { cellValues = range.CellsUsed() .Select(c => c.GetString()) .Where(s => !string.IsNullOrEmpty(s)); + } else + { cellValues = (range as XLRange).CellValues() .Cast() .Select(o => o.ToString()); + } values.AddRange(cellValues); } @@ -366,7 +432,9 @@ private static object TextJoin(List p) var retVal = string.Join(delimiter, values); if (retVal.Length > 32767) + { throw new CellValueException(); + } return retVal; } @@ -390,9 +458,10 @@ private static object Value(List p) private static object NumberValue(List p) { - var numberFormatInfo = new NumberFormatInfo(); - - numberFormatInfo.NumberDecimalSeparator = p.Count > 1 ? p[1] : CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator; + var numberFormatInfo = new NumberFormatInfo + { + NumberDecimalSeparator = p.Count > 1 ? p[1] : CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator + }; numberFormatInfo.CurrencyDecimalSeparator = numberFormatInfo.NumberDecimalSeparator; numberFormatInfo.NumberGroupSeparator = p.Count > 2 ? p[2] : CultureInfo.InvariantCulture.NumberFormat.NumberGroupSeparator; @@ -413,13 +482,19 @@ private static object NumberValue(List p) if (double.TryParse(input, NumberStyles.Any, numberFormatInfo, out var result)) { if (result <= -1e308 || result >= 1e308) + { throw new CellValueException("The value is too large"); + } if (result >= -1e-309 && result <= 1e-309 && result != 0) + { throw new CellValueException("The value is too tiny"); + } if (result >= -1e-308 && result <= 1e-308) + { result = 0d; + } return result; } @@ -446,8 +521,8 @@ private static object Clean(List p) private static object Dollar(List p) { - Double value = p[0]; - int dec = p.Count == 2 ? (int)p[1] : 2; + double value = p[0]; + var dec = p.Count == 2 ? (int)p[1] : 2; return value.ToString("C" + dec); } @@ -462,18 +537,24 @@ private static object Exact(List p) private static object Fixed(List p) { - if (p[0]._token.Value.GetType() == typeof(string)) - throw new ApplicationException("Input type can't be string"); + if (p[0]._token.Value is string) + { + throw new ArgumentException("Input type can't be string"); + } - Double value = p[0]; - int decimal_places = p.Count >= 2 ? (int)p[1] : 2; - Boolean no_commas = p.Count == 3 && p[2]; + double value = p[0]; + var decimal_places = p.Count >= 2 ? (int)p[1] : 2; + var no_commas = p.Count == 3 && p[2]; var retVal = value.ToString("N" + decimal_places); if (no_commas) - return retVal.Replace(",", String.Empty); + { + return retVal.Replace(",", string.Empty); + } else + { return retVal; + } } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/CalcEngine/Functions/XLMath.cs b/ClosedXML/Excel/CalcEngine/Functions/XLMath.cs index 3adcaa5d8..c2b667601 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/XLMath.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/XLMath.cs @@ -1,6 +1,4 @@ using System; -using System.Collections.Generic; -using System.Linq; using System.Text; namespace ClosedXML.Excel.CalcEngine.Functions @@ -9,160 +7,273 @@ public static class XLMath { public static double DegreesToRadians(double degrees) { - return (Math.PI / 180.0) * degrees; + return Math.PI / 180.0 * degrees; } public static double RadiansToDegrees(double radians) { - return (180.0 / Math.PI) * radians; + return 180.0 / Math.PI * radians; } public static double GradsToRadians(double grads) { - return (grads / 200.0) * Math.PI; + return grads / 200.0 * Math.PI; } public static double RadiansToGrads(double radians) { - return (radians / Math.PI) * 200.0; + return radians / Math.PI * 200.0; } public static double DegreesToGrads(double degrees) { - return (degrees / 9.0) * 10.0; + return degrees / 9.0 * 10.0; } public static double GradsToDegrees(double grads) { - return (grads / 10.0) * 9.0; + return grads / 10.0 * 9.0; } public static double ASinh(double x) { - return (Math.Log(x + Math.Sqrt(x * x + 1.0))); + return Math.Log(x + Math.Sqrt(x * x + 1.0)); } public static double ACosh(double x) { - return (Math.Log(x + Math.Sqrt((x * x) - 1.0))); + return Math.Log(x + Math.Sqrt((x * x) - 1.0)); } public static double ATanh(double x) { - return (Math.Log((1.0 + x) / (1.0 - x)) / 2.0); + return Math.Log((1.0 + x) / (1.0 - x)) / 2.0; } public static double ACoth(double x) { //return (Math.Log((x + 1.0) / (x - 1.0)) / 2.0); - return (ATanh(1.0 / x)); + return ATanh(1.0 / x); } public static double ASech(double x) { - return (ACosh(1.0 / x)); + return ACosh(1.0 / x); } public static double ACsch(double x) { - return (ASinh(1.0 / x)); + return ASinh(1.0 / x); } public static double Sech(double x) { - return (1.0 / Math.Cosh(x)); + return 1.0 / Math.Cosh(x); } public static double Csch(double x) { - return (1.0 / Math.Sinh(x)); + return 1.0 / Math.Sinh(x); } public static double Coth(double x) { - return (Math.Cosh(x) / Math.Sinh(x)); + return Math.Cosh(x) / Math.Sinh(x); } - public static double Combin(Int32 n, Int32 k) + public static double Combin(int n, int k) { - if (k == 0) return 1; + if (k == 0) + { + return 1; + } + return n * Combin(n - 1, k - 1) / k; } - public static Boolean IsEven(Int32 value) + public static bool IsEven(int value) { return Math.Abs(value % 2) == 0; } - public static Boolean IsOdd(Int32 value) + public static bool IsOdd(int value) { return Math.Abs(value % 2) != 0; } public static string ToRoman(int number) { - if ((number < 0) || (number > 3999)) throw new ArgumentOutOfRangeException("insert value betwheen 1 and 3999"); - if (number < 1) return string.Empty; - if (number >= 1000) return "M" + ToRoman(number - 1000); - if (number >= 900) return "CM" + ToRoman(number - 900); - if (number >= 500) return "D" + ToRoman(number - 500); - if (number >= 400) return "CD" + ToRoman(number - 400); - if (number >= 100) return "C" + ToRoman(number - 100); - if (number >= 90) return "XC" + ToRoman(number - 90); - if (number >= 50) return "L" + ToRoman(number - 50); - if (number >= 40) return "XL" + ToRoman(number - 40); - if (number >= 10) return "X" + ToRoman(number - 10); - if (number >= 9) return "IX" + ToRoman(number - 9); - if (number >= 5) return "V" + ToRoman(number - 5); - if (number >= 4) return "IV" + ToRoman(number - 4); - if (number >= 1) return "I" + ToRoman(number - 1); + if ((number < 0) || (number > 3999)) + { + throw new ArgumentOutOfRangeException("insert value betwheen 1 and 3999"); + } + + if (number < 1) + { + return string.Empty; + } + + if (number >= 1000) + { + return "M" + ToRoman(number - 1000); + } + + if (number >= 900) + { + return "CM" + ToRoman(number - 900); + } + + if (number >= 500) + { + return "D" + ToRoman(number - 500); + } + + if (number >= 400) + { + return "CD" + ToRoman(number - 400); + } + + if (number >= 100) + { + return "C" + ToRoman(number - 100); + } + + if (number >= 90) + { + return "XC" + ToRoman(number - 90); + } + + if (number >= 50) + { + return "L" + ToRoman(number - 50); + } + + if (number >= 40) + { + return "XL" + ToRoman(number - 40); + } + + if (number >= 10) + { + return "X" + ToRoman(number - 10); + } + + if (number >= 9) + { + return "IX" + ToRoman(number - 9); + } + + if (number >= 5) + { + return "V" + ToRoman(number - 5); + } + + if (number >= 4) + { + return "IV" + ToRoman(number - 4); + } + + if (number >= 1) + { + return "I" + ToRoman(number - 1); + } + throw new ArgumentOutOfRangeException("something bad happened"); } public static int RomanToArabic(string text) { if (text.Length == 0) + { return 0; + } + if (text.StartsWith("M", StringComparison.InvariantCultureIgnoreCase)) + { return 1000 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("CM", StringComparison.InvariantCultureIgnoreCase)) + { return 900 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("D", StringComparison.InvariantCultureIgnoreCase)) + { return 500 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("CD", StringComparison.InvariantCultureIgnoreCase)) + { return 400 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("C", StringComparison.InvariantCultureIgnoreCase)) + { return 100 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("XC", StringComparison.InvariantCultureIgnoreCase)) + { return 90 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("L", StringComparison.InvariantCultureIgnoreCase)) + { return 50 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("XL", StringComparison.InvariantCultureIgnoreCase)) + { return 40 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("X", StringComparison.InvariantCultureIgnoreCase)) + { return 10 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("IX", StringComparison.InvariantCultureIgnoreCase)) + { return 9 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("V", StringComparison.InvariantCultureIgnoreCase)) + { return 5 + RomanToArabic(text.Substring(1)); + } + if (text.StartsWith("IV", StringComparison.InvariantCultureIgnoreCase)) + { return 4 + RomanToArabic(text.Substring(2)); + } + if (text.StartsWith("I", StringComparison.InvariantCultureIgnoreCase)) + { return 1 + RomanToArabic(text.Substring(1)); - + } + throw new ArgumentOutOfRangeException("text is not a valid roman number"); } public static string ChangeBase(long number, int radix) { if (number < 0) + { throw new ArgumentOutOfRangeException("number must be greater or equal to 0"); + } + if (radix < 2) + { throw new ArgumentOutOfRangeException("radix must be greater or equal to 2"); + } + if (radix > 36) + { throw new ArgumentOutOfRangeException("radix must be smaller than or equal to 36"); + } - StringBuilder sb = new StringBuilder(); - long remaining = number; + var sb = new StringBuilder(); + var remaining = number; if (remaining == 0) { @@ -175,9 +286,13 @@ public static string ChangeBase(long number, int radix) remaining = remaining / radix; if (nextDigitDecimal < 10) + { sb.Insert(0, nextDigitDecimal); + } else + { sb.Insert(0, (char)(nextDigitDecimal + 55)); + } } return sb.ToString(); diff --git a/ClosedXML/Excel/CalcEngine/Functions/XLMatrix.cs b/ClosedXML/Excel/CalcEngine/Functions/XLMatrix.cs index 79d6a7026..c8eaf18d6 100644 --- a/ClosedXML/Excel/CalcEngine/Functions/XLMatrix.cs +++ b/ClosedXML/Excel/CalcEngine/Functions/XLMatrix.cs @@ -1,5 +1,5 @@ using System; -using System.Linq; +using System.Text; using System.Text.RegularExpressions; namespace ClosedXML.Excel.CalcEngine.Functions @@ -14,20 +14,20 @@ internal class XLMatrix private int[] pi; public int rows; - public XLMatrix(int iRows, int iCols) // XLMatrix Class constructor + public XLMatrix(int iRows, int iCols) { rows = iRows; cols = iCols; - mat = new double[rows,cols]; + mat = new double[rows, cols]; } - public XLMatrix(Double[,] arr) - :this(arr.GetLength(0), arr.GetLength(1)) + + public XLMatrix(double[,] arr) : this(arr.GetLength(0), arr.GetLength(1)) { var roCount = arr.GetLength(0); var coCount = arr.GetLength(1); - for (int ro = 0; ro < roCount; ro++) + for (var ro = 0; ro < roCount; ro++) { - for (int co = 0; co < coCount; co++) + for (var co = 0; co < coCount; co++) { mat[ro, co] = arr[ro, co]; } @@ -40,31 +40,45 @@ public XLMatrix(Double[,] arr) set { mat[iRow, iCol] = value; } } - public Boolean IsSquare() + public bool IsSquare() { - return (rows == cols); + return rows == cols; } public XLMatrix GetCol(int k) { var m = new XLMatrix(rows, 1); - for (var i = 0; i < rows; i++) m[i, 0] = mat[i, k]; + for (var i = 0; i < rows; i++) + { + m[i, 0] = mat[i, k]; + } + return m; } public void SetCol(XLMatrix v, int k) { - for (var i = 0; i < rows; i++) mat[i, k] = v[i, 0]; + for (var i = 0; i < rows; i++) + { + mat[i, k] = v[i, 0]; + } } public void MakeLU() // Function for LU decomposition { - if (!IsSquare()) throw new InvalidOperationException("The matrix is not square!"); + if (!IsSquare()) + { + throw new InvalidOperationException("The matrix is not square!"); + } + L = IdentityMatrix(rows, cols); U = Duplicate(); pi = new int[rows]; - for (var i = 0; i < rows; i++) pi[i] = i; + for (var i = 0; i < rows; i++) + { + pi[i] = i; + } var k0 = 0; @@ -80,7 +94,9 @@ public void SetCol(XLMatrix v, int k) } } if (p == 0) + { throw new InvalidOperationException("The matrix is singular!"); + } var pom1 = pi[k]; pi[k] = pi[k0]; @@ -94,7 +110,10 @@ public void SetCol(XLMatrix v, int k) L[k0, i] = pom2; } - if (k != k0) detOfP *= -1; + if (k != k0) + { + detOfP *= -1; + } for (var i = 0; i < cols; i++) // Switch rows in U { @@ -105,22 +124,37 @@ public void SetCol(XLMatrix v, int k) for (var i = k + 1; i < rows; i++) { - L[i, k] = U[i, k]/U[k, k]; + L[i, k] = U[i, k] / U[k, k]; for (var j = k; j < cols; j++) - U[i, j] = U[i, j] - L[i, k]*U[k, j]; + { + U[i, j] = U[i, j] - L[i, k] * U[k, j]; + } } } } - public XLMatrix SolveWith(XLMatrix v) // Function solves Ax = v in confirmity with solution vector "v" { - if (rows != cols) throw new InvalidOperationException("The matrix is not square!"); - if (rows != v.rows) throw new ArgumentException("Wrong number of results in solution vector!"); - if (L == null) MakeLU(); + if (rows != cols) + { + throw new InvalidOperationException("The matrix is not square!"); + } + + if (rows != v.rows) + { + throw new ArgumentException("Wrong number of results in solution vector!"); + } + + if (L == null) + { + MakeLU(); + } var b = new XLMatrix(rows, 1); - for (var i = 0; i < rows; i++) b[i, 0] = v[pi[i], 0]; // switch two items in "v" due to permutation matrix + for (var i = 0; i < rows; i++) + { + b[i, 0] = v[pi[i], 0]; // switch two items in "v" due to permutation matrix + } var z = SubsForth(L, b); var x = SubsBack(U, z); @@ -130,7 +164,10 @@ public XLMatrix SolveWith(XLMatrix v) // Function solves Ax = v in confirmity wi public XLMatrix Invert() // Function returns the inverted matrix { - if (L == null) MakeLU(); + if (L == null) + { + MakeLU(); + } var inv = new XLMatrix(rows, cols); @@ -144,21 +181,35 @@ public XLMatrix Invert() // Function returns the inverted matrix return inv; } - public double Determinant() // Function for determinant { - if (L == null) MakeLU(); + if (L == null) + { + MakeLU(); + } + var det = detOfP; - for (var i = 0; i < rows; i++) det *= U[i, i]; + for (var i = 0; i < rows; i++) + { + det *= U[i, i]; + } + return det; } public XLMatrix GetP() // Function returns permutation matrix "P" due to permutation vector "pi" { - if (L == null) MakeLU(); + if (L == null) + { + MakeLU(); + } var matrix = ZeroMatrix(rows, cols); - for (var i = 0; i < rows; i++) matrix[pi[i], i] = 1; + for (var i = 0; i < rows; i++) + { + matrix[pi[i], i] = 1; + } + return matrix; } @@ -166,37 +217,58 @@ public XLMatrix Duplicate() // Function returns the copy of this matrix { var matrix = new XLMatrix(rows, cols); for (var i = 0; i < rows; i++) + { for (var j = 0; j < cols; j++) + { matrix[i, j] = mat[i, j]; + } + } + return matrix; } public static XLMatrix SubsForth(XLMatrix A, XLMatrix b) // Function solves Ax = b for A as a lower triangular matrix { - if (A.L == null) A.MakeLU(); + if (A.L == null) + { + A.MakeLU(); + } + var n = A.rows; var x = new XLMatrix(n, 1); for (var i = 0; i < n; i++) { x[i, 0] = b[i, 0]; - for (var j = 0; j < i; j++) x[i, 0] -= A[i, j]*x[j, 0]; - x[i, 0] = x[i, 0]/A[i, i]; + for (var j = 0; j < i; j++) + { + x[i, 0] -= A[i, j] * x[j, 0]; + } + + x[i, 0] = x[i, 0] / A[i, i]; } return x; } public static XLMatrix SubsBack(XLMatrix A, XLMatrix b) // Function solves Ax = b for A as an upper triangular matrix { - if (A.L == null) A.MakeLU(); + if (A.L == null) + { + A.MakeLU(); + } + var n = A.rows; var x = new XLMatrix(n, 1); for (var i = n - 1; i > -1; i--) { x[i, 0] = b[i, 0]; - for (var j = n - 1; j > i; j--) x[i, 0] -= A[i, j]*x[j, 0]; - x[i, 0] = x[i, 0]/A[i, i]; + for (var j = n - 1; j > i; j--) + { + x[i, 0] -= A[i, j] * x[j, 0]; + } + + x[i, 0] = x[i, 0] / A[i, i]; } return x; } @@ -205,8 +277,13 @@ public static XLMatrix ZeroMatrix(int iRows, int iCols) // Function generates th { var matrix = new XLMatrix(iRows, iCols); for (var i = 0; i < iRows; i++) + { for (var j = 0; j < iCols; j++) + { matrix[i, j] = 0; + } + } + return matrix; } @@ -214,7 +291,10 @@ public static XLMatrix IdentityMatrix(int iRows, int iCols) // Function generate { var matrix = ZeroMatrix(iRows, iCols); for (var i = 0; i < Math.Min(iRows, iCols); i++) + { matrix[i, i] = 1; + } + return matrix; } @@ -223,8 +303,13 @@ public static XLMatrix RandomMatrix(int iRows, int iCols, int dispersion) // Fun var random = new Random(); var matrix = new XLMatrix(iRows, iCols); for (var i = 0; i < iRows; i++) + { for (var j = 0; j < iCols; j++) + { matrix[i, j] = random.Next(-dispersion, dispersion); + } + } + return matrix; } @@ -239,7 +324,10 @@ public static XLMatrix Parse(string ps) // Function parses the matrix from strin for (var i = 0; i < rows.Length; i++) { nums = rows[i].Split(' '); - for (var j = 0; j < nums.Length; j++) matrix[i, j] = double.Parse(nums[j]); + for (var j = 0; j < nums.Length; j++) + { + matrix[i, j] = double.Parse(nums[j]); + } } } catch (FormatException fe) @@ -251,29 +339,50 @@ public static XLMatrix Parse(string ps) // Function parses the matrix from strin public override string ToString() // Function returns matrix as a string { - var s = ""; + var stringBuilder = new StringBuilder(); + for (var i = 0; i < rows; i++) { - for (var j = 0; j < cols; j++) s += String.Format("{0,5:0.00}", mat[i, j]) + " "; - s += "\r\n"; + for (var j = 0; j < cols; j++) + { + stringBuilder.Append($"{mat[i, j],5:0.00} "); + } + + stringBuilder.Append("\r\n"); } - return s; + return stringBuilder.ToString(); } public static XLMatrix Transpose(XLMatrix m) // XLMatrix transpose, for any rectangular matrix { var t = new XLMatrix(m.cols, m.rows); for (var i = 0; i < m.rows; i++) + { for (var j = 0; j < m.cols; j++) + { t[j, i] = m[i, j]; + } + } + return t; } public static XLMatrix Power(XLMatrix m, int pow) // Power matrix to exponent { - if (pow == 0) return IdentityMatrix(m.rows, m.cols); - if (pow == 1) return m.Duplicate(); - if (pow == -1) return m.Invert(); + if (pow == 0) + { + return IdentityMatrix(m.rows, m.cols); + } + + if (pow == 1) + { + return m.Duplicate(); + } + + if (pow == -1) + { + return m.Invert(); + } XLMatrix x; if (pow < 0) @@ -281,12 +390,19 @@ public static XLMatrix Power(XLMatrix m, int pow) // Power matrix to exponent x = m.Invert(); pow *= -1; } - else x = m.Duplicate(); + else + { + x = m.Duplicate(); + } var ret = IdentityMatrix(m.rows, m.cols); while (pow != 0) { - if ((pow & 1) == 1) ret *= x; + if ((pow & 1) == 1) + { + ret *= x; + } + x *= x; pow >>= 1; } @@ -296,56 +412,97 @@ public static XLMatrix Power(XLMatrix m, int pow) // Power matrix to exponent private static void SafeAplusBintoC(XLMatrix A, int xa, int ya, XLMatrix B, int xb, int yb, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows + { for (var j = 0; j < size; j++) // cols { C[i, j] = 0; - if (xa + j < A.cols && ya + i < A.rows) C[i, j] += A[ya + i, xa + j]; - if (xb + j < B.cols && yb + i < B.rows) C[i, j] += B[yb + i, xb + j]; + if (xa + j < A.cols && ya + i < A.rows) + { + C[i, j] += A[ya + i, xa + j]; + } + + if (xb + j < B.cols && yb + i < B.rows) + { + C[i, j] += B[yb + i, xb + j]; + } } + } } private static void SafeAminusBintoC(XLMatrix A, int xa, int ya, XLMatrix B, int xb, int yb, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows + { for (var j = 0; j < size; j++) // cols { C[i, j] = 0; - if (xa + j < A.cols && ya + i < A.rows) C[i, j] += A[ya + i, xa + j]; - if (xb + j < B.cols && yb + i < B.rows) C[i, j] -= B[yb + i, xb + j]; + if (xa + j < A.cols && ya + i < A.rows) + { + C[i, j] += A[ya + i, xa + j]; + } + + if (xb + j < B.cols && yb + i < B.rows) + { + C[i, j] -= B[yb + i, xb + j]; + } } + } } private static void SafeACopytoC(XLMatrix A, int xa, int ya, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows + { for (var j = 0; j < size; j++) // cols { C[i, j] = 0; - if (xa + j < A.cols && ya + i < A.rows) C[i, j] += A[ya + i, xa + j]; + if (xa + j < A.cols && ya + i < A.rows) + { + C[i, j] += A[ya + i, xa + j]; + } } + } } private static void AplusBintoC(XLMatrix A, int xa, int ya, XLMatrix B, int xb, int yb, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows - for (var j = 0; j < size; j++) C[i, j] = A[ya + i, xa + j] + B[yb + i, xb + j]; + { + for (var j = 0; j < size; j++) + { + C[i, j] = A[ya + i, xa + j] + B[yb + i, xb + j]; + } + } } private static void AminusBintoC(XLMatrix A, int xa, int ya, XLMatrix B, int xb, int yb, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows - for (var j = 0; j < size; j++) C[i, j] = A[ya + i, xa + j] - B[yb + i, xb + j]; + { + for (var j = 0; j < size; j++) + { + C[i, j] = A[ya + i, xa + j] - B[yb + i, xb + j]; + } + } } private static void ACopytoC(XLMatrix A, int xa, int ya, XLMatrix C, int size) { for (var i = 0; i < size; i++) // rows - for (var j = 0; j < size; j++) C[i, j] = A[ya + i, xa + j]; + { + for (var j = 0; j < size; j++) + { + C[i, j] = A[ya + i, xa + j]; + } + } } private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix multiplication { - if (A.cols != B.rows) throw new ArgumentException("Wrong dimension of matrix!"); + if (A.cols != B.rows) + { + throw new ArgumentException("Wrong dimension of matrix!"); + } XLMatrix R; @@ -355,9 +512,16 @@ private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix { R = ZeroMatrix(A.rows, B.cols); for (var i = 0; i < R.rows; i++) + { for (var j = 0; j < R.cols; j++) + { for (var k = 0; k < A.cols; k++) - R[i, j] += A[i, k]*B[k, j]; + { + R[i, j] += A[i, k] * B[k, j]; + } + } + } + return R; } @@ -368,11 +532,10 @@ private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix size *= 2; n++; } - - var h = size/2; + var h = size / 2; - var mField = new XLMatrix[n,9]; + var mField = new XLMatrix[n, 9]; /* * 8x8, 8x8, 8x8, ... @@ -383,8 +546,11 @@ private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix for (var i = 0; i < n - 4; i++) // rows { - var z = (int) Math.Pow(2, n - i - 1); - for (var j = 0; j < 9; j++) mField[i, j] = new XLMatrix(z, z); + var z = (int)Math.Pow(2, n - i - 1); + for (var j = 0; j < 9; j++) + { + mField[i, j] = new XLMatrix(z, z); + } } SafeAplusBintoC(A, 0, 0, A, h, h, mField[0, 0], h); @@ -419,25 +585,41 @@ private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix // C11 for (var i = 0; i < Math.Min(h, R.rows); i++) // rows + { for (var j = 0; j < Math.Min(h, R.cols); j++) // cols + { R[i, j] = mField[0, 1 + 1][i, j] + mField[0, 1 + 4][i, j] - mField[0, 1 + 5][i, j] + mField[0, 1 + 7][i, j]; + } + } // C12 for (var i = 0; i < Math.Min(h, R.rows); i++) // rows - for (var j = h; j < Math.Min(2*h, R.cols); j++) // cols + { + for (var j = h; j < Math.Min(2 * h, R.cols); j++) // cols + { R[i, j] = mField[0, 1 + 3][i, j - h] + mField[0, 1 + 5][i, j - h]; + } + } // C21 - for (var i = h; i < Math.Min(2*h, R.rows); i++) // rows + for (var i = h; i < Math.Min(2 * h, R.rows); i++) // rows + { for (var j = 0; j < Math.Min(h, R.cols); j++) // cols + { R[i, j] = mField[0, 1 + 2][i - h, j] + mField[0, 1 + 4][i - h, j]; + } + } // C22 - for (var i = h; i < Math.Min(2*h, R.rows); i++) // rows - for (var j = h; j < Math.Min(2*h, R.cols); j++) // cols + for (var i = h; i < Math.Min(2 * h, R.rows); i++) // rows + { + for (var j = h; j < Math.Min(2 * h, R.cols); j++) // cols + { R[i, j] = mField[0, 1 + 1][i - h, j - h] - mField[0, 1 + 2][i - h, j - h] + mField[0, 1 + 3][i - h, j - h] + mField[0, 1 + 6][i - h, j - h]; + } + } return R; } @@ -445,19 +627,25 @@ private static XLMatrix StrassenMultiply(XLMatrix A, XLMatrix B) // Smart matrix // function for square matrix 2^N x 2^N private static void StrassenMultiplyRun(XLMatrix A, XLMatrix B, XLMatrix C, int l, XLMatrix[,] f) - // A * B into C, level of recursion, matrix field + // A * B into C, level of recursion, matrix field { var size = A.rows; - var h = size/2; + var h = size / 2; if (size < 32) { for (var i = 0; i < C.rows; i++) + { for (var j = 0; j < C.cols; j++) { C[i, j] = 0; - for (var k = 0; k < A.cols; k++) C[i, j] += A[i, k]*B[k, j]; + for (var k = 0; k < A.cols; k++) + { + C[i, j] += A[i, k] * B[k, j]; + } } + } + return; } @@ -491,35 +679,61 @@ private static void StrassenMultiplyRun(XLMatrix A, XLMatrix B, XLMatrix C, int // C11 for (var i = 0; i < h; i++) // rows + { for (var j = 0; j < h; j++) // cols + { C[i, j] = f[l, 1 + 1][i, j] + f[l, 1 + 4][i, j] - f[l, 1 + 5][i, j] + f[l, 1 + 7][i, j]; + } + } // C12 for (var i = 0; i < h; i++) // rows + { for (var j = h; j < size; j++) // cols + { C[i, j] = f[l, 1 + 3][i, j - h] + f[l, 1 + 5][i, j - h]; + } + } // C21 for (var i = h; i < size; i++) // rows + { for (var j = 0; j < h; j++) // cols + { C[i, j] = f[l, 1 + 2][i - h, j] + f[l, 1 + 4][i - h, j]; + } + } // C22 for (var i = h; i < size; i++) // rows + { for (var j = h; j < size; j++) // cols + { C[i, j] = f[l, 1 + 1][i - h, j - h] - f[l, 1 + 2][i - h, j - h] + f[l, 1 + 3][i - h, j - h] + f[l, 1 + 6][i - h, j - h]; + } + } } public static XLMatrix StupidMultiply(XLMatrix m1, XLMatrix m2) // Stupid matrix multiplication { - if (m1.cols != m2.rows) throw new ArgumentException("Wrong dimensions of matrix!"); + if (m1.cols != m2.rows) + { + throw new ArgumentException("Wrong dimensions of matrix!"); + } var result = ZeroMatrix(m1.rows, m2.cols); for (var i = 0; i < result.rows; i++) + { for (var j = 0; j < result.cols; j++) + { for (var k = 0; k < m1.cols; k++) - result[i, j] += m1[i, k]*m2[k, j]; + { + result[i, j] += m1[i, k] * m2[k, j]; + } + } + } + return result; } @@ -527,27 +741,42 @@ private static XLMatrix Multiply(double n, XLMatrix m) // Multiplication by cons { var r = new XLMatrix(m.rows, m.cols); for (var i = 0; i < m.rows; i++) + { for (var j = 0; j < m.cols; j++) - r[i, j] = m[i, j]*n; + { + r[i, j] = m[i, j] * n; + } + } + return r; } - private static XLMatrix Add(XLMatrix m1, XLMatrix m2) + private static XLMatrix Add(XLMatrix m1, XLMatrix m2) { if (m1.rows != m2.rows || m1.cols != m2.cols) + { throw new ArgumentException("Matrices must have the same dimensions!"); + } + var r = new XLMatrix(m1.rows, m1.cols); for (var i = 0; i < r.rows; i++) + { for (var j = 0; j < r.cols; j++) + { r[i, j] = m1[i, j] + m2[i, j]; + } + } + return r; } - public static string NormalizeMatrixString(string matStr) // From Andy - thank you! :) + public static string NormalizeMatrixString(string matStr) { // Remove any multiple spaces while (matStr.IndexOf(" ") != -1) + { matStr = matStr.Replace(" ", " "); + } // Remove any spaces before or after newlines matStr = matStr.Replace(" \r\n", "\r\n"); @@ -558,7 +787,9 @@ public static string NormalizeMatrixString(string matStr) // From Andy - thank y // restore the |’s with \r\n’s matStr = matStr.Replace("\r\n", "|"); while (matStr.LastIndexOf("|") == (matStr.Length - 1)) + { matStr = matStr.Substring(0, matStr.Length - 1); + } matStr = matStr.Replace("|", "\r\n"); return matStr; diff --git a/ClosedXML/Excel/CalcEngine/XLAddressComparer.cs b/ClosedXML/Excel/CalcEngine/XLAddressComparer.cs index ca2c1c62c..45e758577 100644 --- a/ClosedXML/Excel/CalcEngine/XLAddressComparer.cs +++ b/ClosedXML/Excel/CalcEngine/XLAddressComparer.cs @@ -30,8 +30,8 @@ public int GetHashCode(IXLAddress obj) WorksheetName = obj.Worksheet.Name.ToUpperInvariant(), obj.ColumnNumber, obj.RowNumber, - FixedColumn = (_ignoreFixed ? false : obj.FixedColumn), - FixedRow = (_ignoreFixed ? false : obj.FixedRow) + FixedColumn = _ignoreFixed ? false : obj.FixedColumn, + FixedRow = _ignoreFixed ? false : obj.FixedRow }.GetHashCode(); } } diff --git a/ClosedXML/Excel/CalcEngine/XLCalcEngine.cs b/ClosedXML/Excel/CalcEngine/XLCalcEngine.cs index b51782a8f..9853e0df6 100644 --- a/ClosedXML/Excel/CalcEngine/XLCalcEngine.cs +++ b/ClosedXML/Excel/CalcEngine/XLCalcEngine.cs @@ -15,7 +15,7 @@ public XLCalcEngine() public XLCalcEngine(XLWorkbook wb) { _wb = wb; - IdentifierChars = new char[] { '$', ':', '!' }; + IdentifierChars = new[] { '$', ':', '!' }; } public XLCalcEngine(IXLWorksheet ws) : this(ws.Workbook) @@ -25,7 +25,7 @@ public XLCalcEngine(IXLWorksheet ws) : this(ws.Workbook) private IList _cellRanges; - public ExpressionCache ExpressionCache => this._cache; + public ExpressionCache ExpressionCache => _cache; /// /// Get a collection of cell ranges included into the expression. Order is not preserved. @@ -51,7 +51,7 @@ public IEnumerable GetPrecedentRanges(string expression) public IEnumerable GetPrecedentCells(string expression) { - if (!String.IsNullOrWhiteSpace(expression)) + if (!string.IsNullOrWhiteSpace(expression)) { var ranges = GetPrecedentRanges(expression); var visitedCells = new HashSet(new XLAddressComparer(true)); @@ -75,22 +75,32 @@ public override object GetExternalObject(string identifier) .Select(part => { if (part.Contains("!")) + { return part.Substring(0, part.LastIndexOf('!')).ToLower(); + } else + { return null; + } }) .Where(sheet => sheet != null) .Distinct() .ToList(); if (referencedSheetNames.Count == 0) + { return GetCellRangeReference(_ws.Range(identifier)); + } else if (referencedSheetNames.Count > 1) + { throw new ArgumentOutOfRangeException(referencedSheetNames.Last(), "Cross worksheet references may references no more than 1 other worksheet"); + } else { - if (!_wb.TryGetWorksheet(referencedSheetNames.Single(), out IXLWorksheet worksheet)) + if (!_wb.TryGetWorksheet(referencedSheetNames.Single(), out var worksheet)) + { throw new ArgumentOutOfRangeException(referencedSheetNames.Single(), "The required worksheet cannot be found"); + } identifier = identifier.ToLower().Replace(string.Format("{0}!", worksheet.Name.ToLower()), ""); @@ -99,7 +109,7 @@ public override object GetExternalObject(string identifier) } else if (_ws != null) { - if (TryGetNamedRange(identifier, _ws, out IXLNamedRange namedRange)) + if (TryGetNamedRange(identifier, _ws, out var namedRange)) { var references = (namedRange as XLNamedRange).RangeList.Select(r => XLHelper.IsValidRangeAddress(r) @@ -107,16 +117,23 @@ public override object GetExternalObject(string identifier) : new XLCalcEngine(_ws).Evaluate(r.ToString()) ); if (references.Count() == 1) + { return references.Single(); + } + return references; } return GetCellRangeReference(_ws.Range(identifier)); } else if (XLHelper.IsValidRangeAddress(identifier)) + { return identifier; + } else + { return null; + } } private bool TryGetNamedRange(string identifier, IXLWorksheet worksheet, out IXLNamedRange namedRange) @@ -128,11 +145,13 @@ private bool TryGetNamedRange(string identifier, IXLWorksheet worksheet, out IXL private CellRangeReference GetCellRangeReference(IXLRange range) { if (range == null) + { return null; + } var res = new CellRangeReference(range, this); _cellRanges?.Add(res.Range); return res; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Cells/IXLCell.cs b/ClosedXML/Excel/Cells/IXLCell.cs index b143537aa..56855636e 100644 --- a/ClosedXML/Excel/Cells/IXLCell.cs +++ b/ClosedXML/Excel/Cells/IXLCell.cs @@ -12,7 +12,7 @@ public enum XLTableCellType { None, Header, Data, Total } public interface IXLCell { - Boolean Active { get; set; } + bool Active { get; set; } /// Gets this cell's address, relative to the worksheet. /// The cell's address. @@ -22,7 +22,7 @@ public interface IXLCell /// Calculated value of cell formula. Is used for decreasing number of computations perfromed. /// May hold invalid value when flag is True. /// - Object CachedValue { get; } + object CachedValue { get; } /// /// Returns the current region. The current region is a range bounded by any combination of blank rows and blank columns @@ -47,34 +47,34 @@ public interface IXLCell /// Gets or sets the cell's formula with A1 references. /// /// The formula with A1 references. - String FormulaA1 { get; set; } + string FormulaA1 { get; set; } /// /// Gets or sets the cell's formula with R1C1 references. /// /// The formula with R1C1 references. - String FormulaR1C1 { get; set; } + string FormulaR1C1 { get; set; } IXLRangeAddress FormulaReference { get; set; } - Boolean HasArrayFormula { get; } + bool HasArrayFormula { get; } - Boolean HasComment { get; } + bool HasComment { get; } - Boolean HasDataValidation { get; } + bool HasDataValidation { get; } - Boolean HasFormula { get; } + bool HasFormula { get; } - Boolean HasHyperlink { get; } + bool HasHyperlink { get; } - Boolean HasRichText { get; } + bool HasRichText { get; } - Boolean HasSparkline { get; } + bool HasSparkline { get; } /// /// Flag indicating that previously calculated cell value may be not valid anymore and has to be re-evaluated. /// - Boolean NeedsRecalculation { get; } + bool NeedsRecalculation { get; } /// /// Gets or sets a value indicating whether this cell's text should be shared or not. @@ -82,7 +82,7 @@ public interface IXLCell /// /// If false the cell's text will not be shared and stored as an inline value. /// - Boolean ShareString { get; set; } + bool ShareString { get; set; } IXLSparkline Sparkline { get; } @@ -102,7 +102,7 @@ public interface IXLCell /// /// The object containing the value(s) to set. /// - Object Value { get; set; } + object Value { get; set; } IXLWorksheet Worksheet { get; } @@ -114,7 +114,7 @@ public interface IXLCell /// The default scope for the named range is Workbook. /// /// Name of the range. - IXLCell AddToNamed(String rangeName); + IXLCell AddToNamed(string rangeName); /// /// Creates a named range out of this cell. @@ -122,7 +122,7 @@ public interface IXLCell /// Name of the range. /// The scope for the named range. /// - IXLCell AddToNamed(String rangeName, XLScope scope); + IXLCell AddToNamed(string rangeName, XLScope scope); /// /// Creates a named range out of this cell. @@ -131,7 +131,7 @@ public interface IXLCell /// The scope for the named range. /// The comments for the named range. /// - IXLCell AddToNamed(String rangeName, XLScope scope, String comment); + IXLCell AddToNamed(string rangeName, XLScope scope, string comment); /// /// Returns this cell as an IXLRange. @@ -140,19 +140,19 @@ public interface IXLCell IXLCell CellAbove(); - IXLCell CellAbove(Int32 step); + IXLCell CellAbove(int step); IXLCell CellBelow(); - IXLCell CellBelow(Int32 step); + IXLCell CellBelow(int step); IXLCell CellLeft(); - IXLCell CellLeft(Int32 step); + IXLCell CellLeft(int step); IXLCell CellRight(); - IXLCell CellRight(Int32 step); + IXLCell CellRight(int step); /// /// Clears the contents of this cell. @@ -162,11 +162,11 @@ public interface IXLCell IXLCell CopyFrom(IXLCell otherCell); - IXLCell CopyFrom(String otherCell); + IXLCell CopyFrom(string otherCell); IXLCell CopyTo(IXLCell target); - IXLCell CopyTo(String target); + IXLCell CopyTo(string target); /// /// Creates a new comment for the cell, replacing the existing one. @@ -199,7 +199,7 @@ public interface IXLCell /// ClosedXML will try to covert the current value to Boolean. /// An exception will be thrown if the current value cannot be converted to Boolean. /// - Boolean GetBoolean(); + bool GetBoolean(); /// /// Returns the comment for the cell or create a new instance if there is no comment on the cell. @@ -223,12 +223,12 @@ public interface IXLCell /// ClosedXML will try to covert the current value to Double. /// An exception will be thrown if the current value cannot be converted to Double. /// - Double GetDouble(); + double GetDouble(); /// /// Gets the cell's value formatted depending on the cell's data type and style. /// - String GetFormattedString(); + string GetFormattedString(); /// /// Returns a hyperlink for the cell, if any, or creates a new instance is there is no hyperlink. @@ -243,7 +243,7 @@ public interface IXLCell /// /// Gets the cell's value converted to a String. /// - String GetString(); + string GetString(); /// /// Gets the cell's value converted to TimeSpan. @@ -281,7 +281,7 @@ public interface IXLCell /// The IEnumerable data. /// if set to true the data will be transposed before inserting. /// - IXLRange InsertData(IEnumerable data, Boolean transpose); + IXLRange InsertData(IEnumerable data, bool transpose); /// /// Inserts the data of a data table. @@ -306,14 +306,14 @@ public interface IXLCell /// if set to true it will create an Excel table. /// if set to false the table will be created in memory. /// - IXLTable InsertTable(IEnumerable data, Boolean createTable); + IXLTable InsertTable(IEnumerable data, bool createTable); /// /// Creates an Excel table from the given IEnumerable data elements. /// /// The table data. /// Name of the table. - IXLTable InsertTable(IEnumerable data, String tableName); + IXLTable InsertTable(IEnumerable data, string tableName); /// /// Inserts the IEnumerable data elements as a table and returns it. @@ -324,7 +324,7 @@ public interface IXLCell /// if set to true it will create an Excel table. /// if set to false the table will be created in memory. /// - IXLTable InsertTable(IEnumerable data, String tableName, Boolean createTable); + IXLTable InsertTable(IEnumerable data, string tableName, bool createTable); /// /// Inserts the DataTable data elements as a table and returns it. @@ -342,14 +342,14 @@ public interface IXLCell /// if set to true it will create an Excel table. /// if set to false the table will be created in memory. /// - IXLTable InsertTable(DataTable data, Boolean createTable); + IXLTable InsertTable(DataTable data, bool createTable); /// /// Creates an Excel table from the given DataTable data elements. /// /// The table data. /// Name of the table. - IXLTable InsertTable(DataTable data, String tableName); + IXLTable InsertTable(DataTable data, string tableName); /// /// Inserts the DataTable data elements as a table and returns it. @@ -360,7 +360,7 @@ public interface IXLCell /// if set to true it will create an Excel table. /// if set to false the table will be created in memory. /// - IXLTable InsertTable(DataTable data, String tableName, Boolean createTable); + IXLTable InsertTable(DataTable data, string tableName, bool createTable); /// /// Invalidate so the formula will be re-evaluated next time is accessed. @@ -368,20 +368,20 @@ public interface IXLCell /// void InvalidateFormula(); - Boolean IsEmpty(); + bool IsEmpty(); [Obsolete("Use the overload with XLCellsUsedOptions")] - Boolean IsEmpty(Boolean includeFormats); + bool IsEmpty(bool includeFormats); - Boolean IsEmpty(XLCellsUsedOptions options); + bool IsEmpty(XLCellsUsedOptions options); - Boolean IsMerged(); + bool IsMerged(); IXLRange MergedRange(); void Select(); - IXLCell SetActive(Boolean value = true); + IXLCell SetActive(bool value = true); /// /// Sets the type of this cell's data. @@ -395,9 +395,9 @@ public interface IXLCell [Obsolete("Use GetDataValidation to access the existing rule, or CreateDataValidation() to create a new one.")] IXLDataValidation SetDataValidation(); - IXLCell SetFormulaA1(String formula); + IXLCell SetFormulaA1(string formula); - IXLCell SetFormulaR1C1(String formula); + IXLCell SetFormulaR1C1(string formula); void SetHyperlink(XLHyperlink hyperlink); @@ -422,7 +422,7 @@ public interface IXLCell /// string ToString(string format); - Boolean TryGetValue(out T value); + bool TryGetValue(out T value); IXLColumn WorksheetColumn(); diff --git a/ClosedXML/Excel/Cells/IXLCells.cs b/ClosedXML/Excel/Cells/IXLCells.cs index 714890869..9e6318e99 100644 --- a/ClosedXML/Excel/Cells/IXLCells.cs +++ b/ClosedXML/Excel/Cells/IXLCells.cs @@ -15,7 +15,7 @@ public interface IXLCells : IEnumerable /// /// The object containing the value(s) to set. /// - Object Value { set; } + object Value { set; } /// /// Sets the type of the cells' data. @@ -50,13 +50,13 @@ public interface IXLCells : IEnumerable /// Sets the cells' formula with A1 references. /// /// The formula with A1 references. - String FormulaA1 { set; } + string FormulaA1 { set; } /// /// Sets the cells' formula with R1C1 references. /// /// The formula with R1C1 references. - String FormulaR1C1 { set; } + string FormulaR1C1 { set; } IXLStyle Style { get; set; } diff --git a/ClosedXML/Excel/Cells/XLCell.cs b/ClosedXML/Excel/Cells/XLCell.cs index 57bbf70c0..61d0c93b6 100644 --- a/ClosedXML/Excel/Cells/XLCell.cs +++ b/ClosedXML/Excel/Cells/XLCell.cs @@ -1,4 +1,6 @@ using ClosedXML.Excel.InsertData; +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Style; using ClosedXML.Extensions; using System; using System.Collections; @@ -64,7 +66,7 @@ internal class XLCell : XLStylizedBase, IXLCell, IXLStylized #region Fields - private string _cellValue = String.Empty; + private string _cellValue = string.Empty; private XLComment _comment; private XLDataType _dataType; @@ -116,7 +118,10 @@ public XLAddress Address internal set { if (value == null) + { return; + } + _rowNumber = value.RowNumber; _columnNumber = value.ColumnNumber; _fixedRow = value.FixedRow; @@ -129,9 +134,11 @@ public string InnerText get { if (HasRichText) + { return _richText.ToString(); + } - return string.Empty == _cellValue ? FormulaA1 : _cellValue; + return string.IsNullOrEmpty(_cellValue) ? FormulaA1 : _cellValue; } } @@ -148,15 +155,9 @@ internal XLComment CreateComment(int? shapeId = null) #region IXLCell Members - IXLWorksheet IXLCell.Worksheet - { - get { return Worksheet; } - } + IXLWorksheet IXLCell.Worksheet => Worksheet; - IXLAddress IXLCell.Address - { - get { return Address; } - } + IXLAddress IXLCell.Address => Address; IXLRange IXLCell.AsRange() { @@ -167,30 +168,43 @@ public IXLCell SetValue(T value) { if (value is IEnumerable ie && !(value is string)) { - this.InsertData(ie); + InsertData(ie); return this; } else + { return SetValue(value, setTableHeader: true, checkMergedRanges: true); + } } internal IXLCell SetValue(T value, bool setTableHeader, bool checkMergedRanges) { if (checkMergedRanges && IsInferiorMergedCell()) + { return this; + } if (value == null) - return this.Clear(XLClearOptions.Contents); + { + return Clear(XLClearOptions.Contents); + } _richText = null; - _formulaA1 = String.Empty; + _formulaA1 = string.Empty; _formulaR1C1 = null; cachedValue = null; if (setTableHeader) { - if (SetTableHeaderValue(value)) return this; - if (SetTableTotalsRowLabel(value)) return this; + if (SetTableHeaderValue(value)) + { + return this; + } + + if (SetTableTotalsRowLabel(value)) + { + return this; + } } var style = GetStyleForRead(); @@ -205,7 +219,9 @@ internal IXLCell SetValue(T value, bool setTableHeader, bool checkMergedRange // because we are using SetValue (typed). // Only in SetValue(object value) to we try to fall back to a value of a different type if (!parsed) + { throw new ArgumentException($"Unable to set cell value to {value.ObjectToInvariantString()}"); + } SetInternalCellValueString(parsedValue, validate: true, parseToCachedValue: false); @@ -213,16 +229,18 @@ internal IXLCell SetValue(T value, bool setTableHeader, bool checkMergedRange } // TODO: Replace with (string, bool) ValueTuple later - private Tuple SetKnownTypedValue(T value, XLStyleValue style, Boolean acceptString) + private Tuple SetKnownTypedValue(T value, XLStyleValue style, bool acceptString) { string parsedValue; bool parsed; - if (value is String && acceptString || value is char || value is Guid || value is Enum) + if (value is string && acceptString || value is char || value is Guid || value is Enum) { parsedValue = value.ObjectToInvariantString(); _dataType = XLDataType.Text; - if (parsedValue.Contains(Environment.NewLine) && !style.Alignment.WrapText) + if (parsedValue.Contains(XLConstants.NewLine) && !style.Alignment.WrapText) + { Style.Alignment.WrapText = true; + } parsed = true; } @@ -244,7 +262,7 @@ private Tuple SetKnownTypedValue(T value, XLStyleValue style, B parsed = true; SetTimeSpanFormat(style); } - else if (value is Boolean b) + else if (value is bool b) { parsedValue = b ? "1" : "0"; _dataType = XLDataType.Boolean; @@ -279,7 +297,7 @@ private Tuple SetKnownTypedValue(T value, XLStyleValue style, B private string DeduceCellValueByParsing(string value, XLStyleValue style) { - if (String.IsNullOrEmpty(value)) + if (string.IsNullOrEmpty(value)) { _dataType = XLDataType.Text; } @@ -292,25 +310,29 @@ private string DeduceCellValueByParsing(string value, XLStyleValue style) value = value.Substring(1, value.Length - 1); _dataType = XLDataType.Text; - if (value.Contains(Environment.NewLine) && !style.Alignment.WrapText) + if (value.Contains(XLConstants.NewLine) && !style.Alignment.WrapText) + { Style.Alignment.WrapText = true; + } - this.Style.SetIncludeQuotePrefix(); + Style.SetIncludeQuotePrefix(); } else if (!string.Equals(value.Trim(), "NaN", StringComparison.OrdinalIgnoreCase) && - Double.TryParse(value, XLHelper.NumberStyle, XLHelper.ParseCulture, out Double _)) + double.TryParse(value, XLHelper.NumberStyle, XLHelper.ParseCulture, out var _)) + { _dataType = XLDataType.Number; - else if (TimeSpan.TryParse(value, out TimeSpan ts)) + } + else if (TimeSpan.TryParse(value, out var ts)) { value = ts.ToInvariantString(); SetTimeSpanFormat(style); } - else if (DateTime.TryParse(value, out DateTime dt) && dt >= BaseDate) + else if (DateTime.TryParse(value, out var dt) && dt >= BaseDate) { value = dt.ToOADate().ToInvariantString(); SetDateTimeFormat(style, dt.Date == dt); } - else if (Boolean.TryParse(value, out Boolean b)) + else if (bool.TryParse(value, out var b)) { value = b ? "1" : "0"; _dataType = XLDataType.Boolean; @@ -318,8 +340,10 @@ private string DeduceCellValueByParsing(string value, XLStyleValue style) else { _dataType = XLDataType.Text; - if (value.Contains(Environment.NewLine) && !style.Alignment.WrapText) + if (value.Contains(XLConstants.NewLine) && !style.Alignment.WrapText) + { Style.Alignment.WrapText = true; + } } return value; @@ -328,9 +352,11 @@ private string DeduceCellValueByParsing(string value, XLStyleValue style) public T GetValue() { if (TryGetValue(out T retVal)) + { return retVal; + } - throw new FormatException($"Cannot convert {this.Address.ToStringRelative(true)}'s value to " + typeof(T)); + throw new FormatException($"Cannot convert {Address.ToStringRelative(true)}'s value to " + typeof(T)); } public string GetString() @@ -389,13 +415,19 @@ public string GetFormattedString() private object RecalculateFormula(string fA1) { if (string.IsNullOrEmpty(fA1)) + { return null; + } if (IsEvaluating) + { throw new InvalidOperationException("Circular Reference"); + } if (fA1[0] == '{') + { fA1 = fA1.Substring(1, fA1.Length - 2); + } string sName; string cAddress; @@ -403,7 +435,9 @@ private object RecalculateFormula(string fA1) { sName = fA1.Substring(0, fA1.IndexOf('!')); if (sName[0] == '\'') + { sName = sName.Substring(1, sName.Length - 2); + } cAddress = fA1.Substring(fA1.IndexOf('!') + 1); } @@ -421,9 +455,13 @@ private object RecalculateFormula(string fA1) IsEvaluating = true; var referenceCell = Worksheet.Workbook.Worksheet(sName).Cell(cAddress); if (referenceCell.IsEmpty(XLCellsUsedOptions.AllContents)) + { return 0; + } else + { return referenceCell.Value; + } } finally { @@ -441,9 +479,13 @@ private object RecalculateFormula(string fA1) { var referenceCell = Worksheet.Workbook.Worksheet(sName).Cell(cAddress); if (referenceCell.IsEmpty(XLCellsUsedOptions.AllContents)) + { return 0; + } else + { return referenceCell.Value; + } } retVal = Worksheet.Evaluate(fA1); @@ -453,8 +495,10 @@ private object RecalculateFormula(string fA1) IsEvaluating = false; } - if (retVal is IEnumerable retValEnumerable && !(retVal is String)) + if (retVal is IEnumerable retValEnumerable && !(retVal is string)) + { return retValEnumerable.Cast().First(); + } return retVal; } @@ -473,7 +517,7 @@ public void InvalidateFormula() /// /// Flag indicating whether a recalculation must be performed even is cell does not need it. /// Null if cell does not contain a formula. Calculated value otherwise. - public Object Evaluate(Boolean force = false) + public object Evaluate(bool force = false) { if (force || NeedsRecalculation) { @@ -483,7 +527,9 @@ public Object Evaluate(Boolean force = false) UpdateCachedValueFromDataType(); } else + { CachedValue = null; + } EvaluatedAtVersion = Worksheet.Workbook.RecalculationCounter; NeedsRecalculation = false; @@ -491,88 +537,130 @@ public Object Evaluate(Boolean force = false) return CachedValue; } - internal void SetInternalCellValueString(String cellValue) + internal void SetInternalCellValueString(string cellValue) { - SetInternalCellValueString(cellValue, validate: false, parseToCachedValue: this.HasFormula); + SetInternalCellValueString(cellValue, validate: false, parseToCachedValue: HasFormula); } - private void SetInternalCellValueString(String cellValue, Boolean validate, Boolean parseToCachedValue) + private void SetInternalCellValueString(string cellValue, bool validate, bool parseToCachedValue) { - if (validate) + if (validate && cellValue.Length > 32767) { - if (cellValue.Length > 32767) throw new ArgumentOutOfRangeException(nameof(cellValue), "Cells can hold a maximum of 32,767 characters."); + throw new ArgumentOutOfRangeException(nameof(cellValue), "Cells can hold a maximum of 32,767 characters."); } - this._cellValue = cellValue; + _cellValue = cellValue; if (parseToCachedValue) + { CachedValue = ParseCellValueFromString(); + } } private void UpdateCachedValueFromDataType() { if (CachedValue is double d) { - if (this.DataType == XLDataType.DateTime && d.IsValidOADateNumber()) + if (DataType == XLDataType.DateTime && d.IsValidOADateNumber()) + { CachedValue = DateTime.FromOADate(d); - else if (this.DataType == XLDataType.TimeSpan) + } + else if (DataType == XLDataType.TimeSpan) + { CachedValue = XLHelper.GetTimeSpan(d); + } } else if (CachedValue is DateTime dt) { - if (this.DataType == XLDataType.Number) + if (DataType == XLDataType.Number) + { CachedValue = dt.ToOADate(); - else if (this.DataType == XLDataType.TimeSpan) + } + else if (DataType == XLDataType.TimeSpan) + { CachedValue = XLHelper.GetTimeSpan(dt.ToOADate()); + } } else if (CachedValue is TimeSpan ts) { - if (this.DataType == XLDataType.DateTime) + if (DataType == XLDataType.DateTime) + { CachedValue = DateTime.FromOADate(ts.TotalDays); - else if (this.DataType == XLDataType.Number) + } + else if (DataType == XLDataType.Number) + { CachedValue = ts.TotalDays; + } + } + } + + internal void SetDateValue(string text) + { + if (double.TryParse(text, XLHelper.NumberStyle, XLHelper.ParseCulture, out var doubleValue)) + { + SetInternalCellValueString(doubleValue.ToInvariantString()); + } + else + { + SetInternalCellValueString(DateTime.Parse(text).ToOADate().ToInvariantString()); } } internal void SetDataTypeFast(XLDataType dataType) { - this._dataType = dataType; + _dataType = dataType; } - private Object ParseCellValueFromString() + private object ParseCellValueFromString() { - return ParseCellValueFromString(_cellValue, _dataType, out String error); + return ParseCellValueFromString(_cellValue, _dataType, out var error); } - private Object ParseCellValueFromString(String cellValue, XLDataType dataType, out String error) + private object ParseCellValueFromString(string cellValue, XLDataType dataType, out string error) { error = ""; - if ("" == cellValue) + if (string.IsNullOrEmpty(cellValue)) + { return ""; + } if (dataType == XLDataType.Boolean) { - if (bool.TryParse(cellValue, out Boolean b)) + if (bool.TryParse(cellValue, out var b)) + { return b; + } else if (cellValue == "0") + { return false; + } else if (cellValue == "1") + { return true; + } else + { return !string.IsNullOrEmpty(cellValue); + } } if (dataType == XLDataType.DateTime) { - if (Double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out Double d)) + if (double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out var d)) { if (d.IsValidOADateNumber()) + { return DateTime.FromOADate(d); + } else + { return d; + } } - else if (DateTime.TryParse(cellValue, out DateTime dt)) + else if (DateTime.TryParse(cellValue, out var dt)) + { return dt; + } else { error = string.Format("Cannot set data type to DateTime because '{0}' is not recognized as a date.", cellValue); @@ -582,15 +670,17 @@ private Object ParseCellValueFromString(String cellValue, XLDataType dataType, o if (dataType == XLDataType.Number) { var v = cellValue; - Double factor = 1.0; + var factor = 1.0; if (v.EndsWith("%")) { v = v.Substring(0, v.Length - 1); factor = 1 / 100.0; } - if (Double.TryParse(v, XLHelper.NumberStyle, CultureInfo.InvariantCulture, out Double d)) + if (double.TryParse(v, XLHelper.NumberStyle, CultureInfo.InvariantCulture, out var d)) + { return d * factor; + } else { error = string.Format("Cannot set data type to Number because '{0}' is not recognized as a number.", cellValue); @@ -600,10 +690,14 @@ private Object ParseCellValueFromString(String cellValue, XLDataType dataType, o if (dataType == XLDataType.TimeSpan) { - if (TimeSpan.TryParse(cellValue, out TimeSpan ts)) + if (TimeSpan.TryParse(cellValue, out var ts)) + { return ts; - else if (Double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out Double d)) + } + else if (double.TryParse(cellValue, XLHelper.NumberStyle, XLHelper.ParseCulture, out var d)) + { return XLHelper.GetTimeSpan(d); + } else { error = string.Format("Cannot set data type to TimeSpan because '{0}' is not recognized as a TimeSpan.", cellValue); @@ -618,10 +712,10 @@ private Object ParseCellValueFromString(String cellValue, XLDataType dataType, o public string ToString(string format) { - return (format.ToUpper()) switch + return format.ToUpper(CultureInfo.InvariantCulture) switch { - "A" => this.Address.ToString(), - "F" => HasFormula ? this.FormulaA1 : string.Empty, + "A" => Address.ToString(), + "F" => HasFormula ? FormulaA1 : string.Empty, "NF" => Style.NumberFormat.Format, "FG" => Style.Font.FontColor.ToString(), "BG" => Style.Fill.BackgroundColor.ToString(), @@ -634,8 +728,8 @@ public object Value { get { - if (!String.IsNullOrWhiteSpace(_formulaA1) || - !String.IsNullOrEmpty(_formulaR1C1)) + if (!string.IsNullOrWhiteSpace(_formulaA1) || + !string.IsNullOrEmpty(_formulaR1C1)) { return Evaluate(); } @@ -646,30 +740,58 @@ public object Value set { if (IsInferiorMergedCell()) + { return; + } - FormulaA1 = String.Empty; + FormulaA1 = string.Empty; - if (value is XLCells) throw new ArgumentException("Cannot assign IXLCells object to the cell value."); + if (value is XLCells) + { + throw new ArgumentException("Cannot assign IXLCells object to the cell value."); + } - if (SetTableHeaderValue(value)) return; + if (SetTableHeaderValue(value)) + { + return; + } - if (SetRangeRows(value)) return; + if (SetRangeRows(value)) + { + return; + } - if (SetRangeColumns(value)) return; + if (SetRangeColumns(value)) + { + return; + } - if (SetDataTable(value)) return; + if (SetDataTable(value)) + { + return; + } - if (SetEnumerable(value)) return; + if (SetEnumerable(value)) + { + return; + } - if (SetRange(value)) return; + if (SetRange(value)) + { + return; + } if (!SetRichText(value)) + { SetValue(value); + } CachedValue = null; - if (_cellValue.Length > 32767) throw new ArgumentOutOfRangeException(nameof(value), "Cells can hold only 32,767 characters."); + if (_cellValue.Length > 32767) + { + throw new ArgumentOutOfRangeException(nameof(value), "Cells can hold only 32,767 characters."); + } } } @@ -688,31 +810,37 @@ public IXLTable InsertTable(IEnumerable data, string tableName) return InsertTable(data, tableName, true); } - public IXLTable InsertTable(IEnumerable data, String tableName, Boolean createTable) + public IXLTable InsertTable(IEnumerable data, string tableName, bool createTable) { return InsertTable(data, tableName, createTable, addHeadings: true, transpose: false); } - public IXLTable InsertTable(IEnumerable data, String tableName, Boolean createTable, Boolean addHeadings, Boolean transpose) + public IXLTable InsertTable(IEnumerable data, string tableName, bool createTable, bool addHeadings, bool transpose) { var reader = InsertDataReaderFactory.Instance.CreateReader(data); return InsertTableInternal(reader, tableName, createTable, addHeadings, transpose); } - private IXLTable InsertTableInternal(IInsertDataReader reader, String tableName, Boolean createTable, Boolean addHeadings, - Boolean transpose) + private IXLTable InsertTableInternal(IInsertDataReader reader, string tableName, bool createTable, bool addHeadings, + bool transpose) { - if (createTable && this.Worksheet.Tables.Any(t => t.Contains(this))) - throw new InvalidOperationException(String.Format("This cell '{0}' is already part of a table.", this.Address.ToString())); + if (createTable && Worksheet.Tables.Any(t => t.Contains(this))) + { + throw new InvalidOperationException(string.Format("This cell '{0}' is already part of a table.", Address.ToString())); + } var range = InsertDataInternal(reader, addHeadings, transpose); if (createTable) + { // Create a table and save it in the file return tableName == null ? range.CreateTable() : range.CreateTable(tableName); + } else + { // Create a table, but keep it in memory. Saved file will contain only "raw" data and column headers return tableName == null ? range.AsTable() : range.AsTable(tableName); + } } public IXLTable InsertTable(DataTable data) @@ -720,35 +848,43 @@ public IXLTable InsertTable(DataTable data) return InsertTable(data, null, true); } - public IXLTable InsertTable(DataTable data, Boolean createTable) + public IXLTable InsertTable(DataTable data, bool createTable) { return InsertTable(data, null, createTable); } - public IXLTable InsertTable(DataTable data, String tableName) + public IXLTable InsertTable(DataTable data, string tableName) { return InsertTable(data, tableName, true); } - public IXLTable InsertTable(DataTable data, String tableName, Boolean createTable) + public IXLTable InsertTable(DataTable data, string tableName, bool createTable) { if (data == null || data.Columns.Count == 0) + { return null; + } if (XLHelper.IsValidA1Address(tableName) || XLHelper.IsValidRCAddress(tableName)) + { throw new InvalidOperationException($"Table name cannot be a valid Cell Address '{tableName}'."); + } - if (createTable && this.Worksheet.Tables.Any(t => t.Contains(this))) - throw new InvalidOperationException($"This cell '{this.Address}' is already part of a table."); + if (createTable && Worksheet.Tables.Any(t => t.Contains(this))) + { + throw new InvalidOperationException($"This cell '{Address}' is already part of a table."); + } var reader = InsertDataReaderFactory.Instance.CreateReader(data); return InsertTableInternal(reader, tableName, createTable, addHeadings: true, transpose: false); } - internal XLRange InsertDataInternal(IInsertDataReader reader, Boolean addHeadings, Boolean transpose) + internal XLRange InsertDataInternal(IInsertDataReader reader, bool addHeadings, bool transpose) { if (reader == null) + { return null; + } var currentRowNumber = _rowNumber; var currentColumnNumber = _columnNumber; @@ -799,9 +935,13 @@ void incrementRecordPosition() void resetRecordPosition() { if (transpose) + { currentRowNumber = _rowNumber; + } else + { currentColumnNumber = _columnNumber; + } } ////////////////////////////////////////////////////// @@ -820,7 +960,7 @@ void resetRecordPosition() if (addHeadings) { - for (int i = 0; i < reader.GetPropertiesCount(); i++) + for (var i = 0; i < reader.GetPropertiesCount(); i++) { var propertyName = reader.GetPropertyName(i); Worksheet.SetValue(propertyName, currentRowNumber, currentColumnNumber); @@ -854,27 +994,41 @@ void resetRecordPosition() public XLTableCellType TableCellType() { - var table = this.Worksheet.Tables.FirstOrDefault(t => t.AsRange().Contains(this)); - if (table == null) return XLTableCellType.None; + var table = Worksheet.Tables.FirstOrDefault(t => t.AsRange().Contains(this)); + if (table == null) + { + return XLTableCellType.None; + } + + if (table.ShowHeaderRow && table.HeadersRow().RowNumber().Equals(_rowNumber)) + { + return XLTableCellType.Header; + } - if (table.ShowHeaderRow && table.HeadersRow().RowNumber().Equals(this._rowNumber)) return XLTableCellType.Header; - if (table.ShowTotalsRow && table.TotalsRow().RowNumber().Equals(this._rowNumber)) return XLTableCellType.Total; + if (table.ShowTotalsRow && table.TotalsRow().RowNumber().Equals(_rowNumber)) + { + return XLTableCellType.Total; + } return XLTableCellType.Data; } public IXLRange InsertData(IEnumerable data) { - if (data == null || data is String) + if (data == null || data is string) + { return null; + } return InsertData(data, transpose: false); } - public IXLRange InsertData(IEnumerable data, Boolean transpose) + public IXLRange InsertData(IEnumerable data, bool transpose) { - if (data == null || data is String) + if (data == null || data is string) + { return null; + } var reader = InsertDataReaderFactory.Instance.CreateReader(data); return InsertDataInternal(reader, addHeadings: false, transpose: transpose); @@ -883,7 +1037,9 @@ public IXLRange InsertData(IEnumerable data, Boolean transpose) public IXLRange InsertData(DataTable dataTable) { if (dataTable == null) + { return null; + } var reader = InsertDataReaderFactory.Instance.CreateReader(dataTable); return InsertDataInternal(reader, addHeadings: false, transpose: false); @@ -900,7 +1056,10 @@ public XLDataType DataType get { return _dataType; } set { - if (_dataType == value) return; + if (_dataType == value) + { + return; + } if (HasRichText) { @@ -924,8 +1083,8 @@ public XLDataType DataType _cellValue = ts.TotalDays.ToInvariantString(); break; - case Boolean b: - _cellValue = b ? "True" : "False"; + case bool b: + _cellValue = b ? "true" : "false"; break; default: @@ -935,10 +1094,12 @@ public XLDataType DataType } else { - var v = ParseCellValueFromString(_cellValue, value, out String error); + var v = ParseCellValueFromString(_cellValue, value, out var error); - if (!String.IsNullOrWhiteSpace(error)) + if (!string.IsNullOrWhiteSpace(error)) + { throw new ArgumentException(error, nameof(value)); + } _cellValue = v?.ObjectToInvariantString() ?? ""; @@ -949,17 +1110,21 @@ public XLDataType DataType _cellValue = d.ToOADate().ToInvariantString(); if (style.NumberFormat.Format.Length == 0 && style.NumberFormat.NumberFormatId == 0) + { Style.NumberFormat.NumberFormatId = _cellValue.Contains('.') ? 22 : 14; + } break; case TimeSpan ts: if (style.NumberFormat.Format.Length == 0 && style.NumberFormat.NumberFormatId == 0) + { Style.NumberFormat.NumberFormatId = 46; + } break; - case Boolean b: + case bool b: _cellValue = b ? "1" : "0"; break; } @@ -969,9 +1134,13 @@ public XLDataType DataType _dataType = value; if (HasFormula && !NeedsRecalculation) + { UpdateCachedValueFromDataType(); + } else + { CachedValue = null; + } } } @@ -988,7 +1157,9 @@ internal IXLCell Clear(XLClearOptions clearOptions, bool calledFromRange) { var firstOrDefault = Worksheet.Internals.MergedRanges.GetIntersectedRanges(Address).FirstOrDefault(); if (firstOrDefault != null) + { firstOrDefault.Clear(clearOptions); + } } else { @@ -996,15 +1167,19 @@ internal IXLCell Clear(XLClearOptions clearOptions, bool calledFromRange) { SetHyperlink(null); _richText = null; - _cellValue = String.Empty; - FormulaA1 = String.Empty; + _cellValue = string.Empty; + FormulaA1 = string.Empty; } if (clearOptions.HasFlag(XLClearOptions.DataType)) + { _dataType = XLDataType.Text; + } if (clearOptions.HasFlag(XLClearOptions.NormalFormats)) + { SetStyle(Worksheet.Style); + } if (clearOptions.HasFlag(XLClearOptions.ConditionalFormats)) { @@ -1012,7 +1187,9 @@ internal IXLCell Clear(XLClearOptions clearOptions, bool calledFromRange) } if (clearOptions.HasFlag(XLClearOptions.Comments)) + { _comment = null; + } if (clearOptions.HasFlag(XLClearOptions.Sparklines)) { @@ -1043,22 +1220,26 @@ public string FormulaA1 { get { - if (String.IsNullOrWhiteSpace(_formulaA1)) + if (string.IsNullOrWhiteSpace(_formulaA1)) { - if (!String.IsNullOrWhiteSpace(_formulaR1C1)) + if (!string.IsNullOrWhiteSpace(_formulaR1C1)) { _formulaA1 = GetFormulaA1(_formulaR1C1); return FormulaA1; } - return String.Empty; + return string.Empty; } if (_formulaA1.Trim()[0] == '=') + { return _formulaA1.Substring(1); + } if (_formulaA1.Trim().StartsWith("{=")) + { return "{" + _formulaA1.Substring(2); + } return _formulaA1; } @@ -1066,11 +1247,13 @@ public string FormulaA1 set { if (IsInferiorMergedCell()) + { return; + } InvalidateFormula(); - _formulaA1 = String.IsNullOrWhiteSpace(value) ? null : value; + _formulaA1 = string.IsNullOrWhiteSpace(value) ? null : value; _formulaR1C1 = null; } @@ -1080,8 +1263,10 @@ public string FormulaR1C1 { get { - if (String.IsNullOrWhiteSpace(_formulaR1C1)) + if (string.IsNullOrWhiteSpace(_formulaR1C1)) + { _formulaR1C1 = GetFormulaR1C1(FormulaA1); + } return _formulaR1C1; } @@ -1089,11 +1274,13 @@ public string FormulaR1C1 set { if (IsInferiorMergedCell()) + { return; + } InvalidateFormula(); - _formulaR1C1 = String.IsNullOrWhiteSpace(value) ? null : value; + _formulaR1C1 = string.IsNullOrWhiteSpace(value) ? null : value; _formulaA1 = null; } @@ -1112,20 +1299,30 @@ public void SetHyperlink(XLHyperlink hyperlink) _hyperlink = hyperlink; - if (_hyperlink == null) return; + if (_hyperlink == null) + { + return; + } _hyperlink.Worksheet = Worksheet; _hyperlink.Cell = this; Worksheet.Hyperlinks.Add(_hyperlink); - if (SettingHyperlink) return; + if (SettingHyperlink) + { + return; + } if (GetStyleForRead().Font.FontColor.Equals(Worksheet.StyleValue.Font.FontColor)) + { Style.Font.FontColor = XLColor.FromTheme(XLThemeColor.Hyperlink); + } if (GetStyleForRead().Font.Underline == Worksheet.StyleValue.Font.Underline) + { Style.Font.Underline = XLFontUnderlineValues.Single; + } } public XLHyperlink CreateHyperlink() @@ -1181,13 +1378,17 @@ public bool NeedsRecalculation { get { - if (String.IsNullOrWhiteSpace(_formulaA1) && String.IsNullOrEmpty(_formulaR1C1)) + if (string.IsNullOrWhiteSpace(_formulaA1) && string.IsNullOrEmpty(_formulaR1C1)) + { return false; + } if (NeedsRecalculationEvaluatedAtVersion == Worksheet.Workbook.RecalculationCounter) + { return _recalculationNeededLastValue; + } - bool res = EvaluatedAtVersion < ModifiedAtVersion || // the cell itself was modified + var res = EvaluatedAtVersion < ModifiedAtVersion || // the cell itself was modified GetAffectingCells().Any(cell => cell.ModifiedAtVersion > EvaluatedAtVersion || // the affecting cell was modified after this one was evaluated cell.EvaluatedAtVersion > EvaluatedAtVersion || // the affecting cell was evaluated after this one (normally this should not happen) cell.NeedsRecalculation); // the affecting cell needs recalculation (recursion to walk through dependencies) @@ -1227,21 +1428,25 @@ private IEnumerable GetAffectingCells() /// private long NeedsRecalculationEvaluatedAtVersion { get; set; } - private Object cachedValue; + private object cachedValue; - public Object CachedValue + public object CachedValue { get { if (!HasFormula && cachedValue == null) + { cachedValue = Value; + } return cachedValue; } private set { if (value != null && !HasFormula) + { throw new InvalidOperationException("Cached values can be set only for cells with formulas"); + } cachedValue = value; } @@ -1252,10 +1457,7 @@ public IXLRichText GetRichText() return _richText ?? CreateRichText(); } - public bool HasRichText - { - get { return _richText != null; } - } + public bool HasRichText => _richText != null; public IXLRichText CreateRichText() { @@ -1272,17 +1474,14 @@ IXLComment IXLCell.GetComment() return GetComment(); } - public bool HasComment - { - get { return _comment != null; } - } + public bool HasComment => _comment != null; IXLComment IXLCell.CreateComment() { return CreateComment(shapeId: null); } - public Boolean IsMerged() + public bool IsMerged() { return Worksheet.Internals.MergedRanges.Contains(this); } @@ -1296,57 +1495,82 @@ public IXLRange MergedRange() .FirstOrDefault(); } - public Boolean IsEmpty() + public bool IsEmpty() { return IsEmpty(XLCellsUsedOptions.AllContents); } [Obsolete("Use the overload with XLCellsUsedOptions")] - public Boolean IsEmpty(Boolean includeFormats) + public bool IsEmpty(bool includeFormats) { return IsEmpty(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents); } - public Boolean IsEmpty(XLCellsUsedOptions options) + public bool IsEmpty(XLCellsUsedOptions options) { - if (InnerText.Length > 0) + if (options.HasFlag(XLCellsUsedOptions.Contents) && InnerText.Length > 0) + { return false; + } if (options.HasFlag(XLCellsUsedOptions.NormalFormats)) { if (StyleValue.IncludeQuotePrefix) + { return false; + } if (!StyleValue.Equals(Worksheet.StyleValue)) + { return false; + } if (StyleValue.Equals(Worksheet.StyleValue)) { - if (Worksheet.Internals.RowsCollection.TryGetValue(_rowNumber, out XLRow row) && !row.StyleValue.Equals(Worksheet.StyleValue)) + if (Worksheet.Internals.RowsCollection.TryGetValue(_rowNumber, out var row) && !row.StyleValue.Equals(Worksheet.StyleValue)) + { return false; + } - if (Worksheet.Internals.ColumnsCollection.TryGetValue(_columnNumber, out XLColumn column) && !column.StyleValue.Equals(Worksheet.StyleValue)) + if (Worksheet.Internals.ColumnsCollection.TryGetValue(_columnNumber, out var column) && !column.StyleValue.Equals(Worksheet.StyleValue)) + { return false; + } } } if (options.HasFlag(XLCellsUsedOptions.MergedRanges) && IsMerged()) + { return false; + } if (options.HasFlag(XLCellsUsedOptions.Comments) && HasComment) + { return false; + } if (options.HasFlag(XLCellsUsedOptions.DataValidation) && HasDataValidation) + { return false; + } if (options.HasFlag(XLCellsUsedOptions.ConditionalFormats) && Worksheet.ConditionalFormats.SelectMany(cf => cf.Ranges).Any(range => range.Contains(this))) + { return false; + } if (options.HasFlag(XLCellsUsedOptions.Sparklines) && HasSparkline) + { return false; + } + + if (options.HasFlag(XLCellsUsedOptions.DataType) && DataType != XLDataType.Text) + { + return false; + } return true; } @@ -1367,7 +1591,7 @@ public IXLCell CopyTo(IXLCell target) return target; } - public IXLCell CopyTo(String target) + public IXLCell CopyTo(string target) { return CopyTo(GetTargetCell(target, Worksheet)); } @@ -1377,24 +1601,24 @@ public IXLCell CopyFrom(IXLCell otherCell) return CopyFrom(otherCell as XLCell, XLCellCopyOptions.All); } - public IXLCell CopyFrom(String otherCell) + public IXLCell CopyFrom(string otherCell) { return CopyFrom(GetTargetCell(otherCell, Worksheet)); } - public IXLCell SetFormulaA1(String formula) + public IXLCell SetFormulaA1(string formula) { FormulaA1 = formula; return this; } - public IXLCell SetFormulaR1C1(String formula) + public IXLCell SetFormulaR1C1(string formula) { FormulaR1C1 = formula; return this; } - public Boolean HasSparkline => Sparkline != null; + public bool HasSparkline => Sparkline != null; /// The sparkline assigned to the cell public IXLSparkline Sparkline => Worksheet.SparklineGroups.GetSparkline(this); @@ -1404,10 +1628,7 @@ public IXLDataValidation GetDataValidation() return FindDataValidation() ?? CreateDataValidation(); } - public Boolean HasDataValidation - { - get { return FindDataValidation() != null; } - } + public bool HasDataValidation => FindDataValidation() != null; /// /// Get the data validation rule containing current cell. @@ -1448,36 +1669,37 @@ public IXLConditionalFormat AddConditionalFormat() return AsRange().AddConditionalFormat(); } - public Boolean Active + public bool Active { get { return Worksheet.ActiveCell == this; } set { if (value) + { Worksheet.ActiveCell = this; + } else if (Active) + { Worksheet.ActiveCell = null; + } } } - public IXLCell SetActive(Boolean value = true) + public IXLCell SetActive(bool value = true) { Active = value; return this; } - public Boolean HasHyperlink - { - get { return _hyperlink != null; } - } + public bool HasHyperlink => _hyperlink != null; - public Boolean TryGetValue(out T value) + public bool TryGetValue(out T value) { var targetType = typeof(T); var underlyingType = targetType.GetUnderlyingType(); var isNullable = targetType.IsNullableType(); - Object currentValue; + object currentValue; try { currentValue = Value; @@ -1489,30 +1711,48 @@ public Boolean TryGetValue(out T value) return false; } - if (isNullable && (currentValue == null || currentValue is string s && String.IsNullOrEmpty(s))) + if (isNullable && (currentValue == null || currentValue is string s && string.IsNullOrEmpty(s))) { value = default; return true; } - if (targetType != typeof(String) // Strings are handled later and have some specifics to UTF handling + if (targetType != typeof(string) // Strings are handled later and have some specifics to UTF handling && currentValue is T t) { value = t; return true; } - if (TryGetDateTimeValue(out value, currentValue)) return true; + if (TryGetDateTimeValue(out value, currentValue)) + { + return true; + } - if (TryGetTimeSpanValue(out value, currentValue)) return true; + if (TryGetTimeSpanValue(out value, currentValue)) + { + return true; + } - if (TryGetBooleanValue(out value, currentValue)) return true; + if (TryGetBooleanValue(out value, currentValue)) + { + return true; + } - if (TryGetRichStringValue(out value)) return true; + if (TryGetRichStringValue(out value)) + { + return true; + } - if (TryGetStringValue(out value, currentValue)) return true; + if (TryGetStringValue(out value, currentValue)) + { + return true; + } - if (TryGetHyperlink(out value)) return true; + if (TryGetHyperlink(out value)) + { + return true; + } if (currentValue.IsNumber()) { @@ -1530,17 +1770,60 @@ public Boolean TryGetValue(out T value) var strValue = currentValue.ToString(); - if (underlyingType == typeof(sbyte)) return TryGetBasicValue(strValue, sbyte.TryParse, out value); - if (underlyingType == typeof(byte)) return TryGetBasicValue(strValue, byte.TryParse, out value); - if (underlyingType == typeof(short)) return TryGetBasicValue(strValue, short.TryParse, out value); - if (underlyingType == typeof(ushort)) return TryGetBasicValue(strValue, ushort.TryParse, out value); - if (underlyingType == typeof(int)) return TryGetBasicValue(strValue, int.TryParse, out value); - if (underlyingType == typeof(uint)) return TryGetBasicValue(strValue, uint.TryParse, out value); - if (underlyingType == typeof(long)) return TryGetBasicValue(strValue, long.TryParse, out value); - if (underlyingType == typeof(ulong)) return TryGetBasicValue(strValue, ulong.TryParse, out value); - if (underlyingType == typeof(float)) return TryGetBasicValue(strValue, float.TryParse, out value); - if (underlyingType == typeof(double)) return TryGetBasicValue(strValue, double.TryParse, out value); - if (underlyingType == typeof(decimal)) return TryGetBasicValue(strValue, decimal.TryParse, out value); + if (underlyingType == typeof(sbyte)) + { + return TryGetBasicValue(strValue, sbyte.TryParse, out value); + } + + if (underlyingType == typeof(byte)) + { + return TryGetBasicValue(strValue, byte.TryParse, out value); + } + + if (underlyingType == typeof(short)) + { + return TryGetBasicValue(strValue, short.TryParse, out value); + } + + if (underlyingType == typeof(ushort)) + { + return TryGetBasicValue(strValue, ushort.TryParse, out value); + } + + if (underlyingType == typeof(int)) + { + return TryGetBasicValue(strValue, int.TryParse, out value); + } + + if (underlyingType == typeof(uint)) + { + return TryGetBasicValue(strValue, uint.TryParse, out value); + } + + if (underlyingType == typeof(long)) + { + return TryGetBasicValue(strValue, long.TryParse, out value); + } + + if (underlyingType == typeof(ulong)) + { + return TryGetBasicValue(strValue, ulong.TryParse, out value); + } + + if (underlyingType == typeof(float)) + { + return TryGetBasicValue(strValue, float.TryParse, out value); + } + + if (underlyingType == typeof(double)) + { + return TryGetBasicValue(strValue, double.TryParse, out value); + } + + if (underlyingType == typeof(decimal)) + { + return TryGetBasicValue(strValue, decimal.TryParse, out value); + } if (underlyingType.IsEnum) { @@ -1585,7 +1868,7 @@ private static bool TryGetDateTimeValue(out T value, object currentValue) } } - if (DateTime.TryParse(currentValue.ToString(), out DateTime ts)) + if (DateTime.TryParse(currentValue.ToString(), out var ts)) { value = (T)Convert.ChangeType(ts, typeof(T)); return true; @@ -1614,7 +1897,7 @@ private static bool TryGetTimeSpanValue(out T value, object currentValue) if (currentValue is T v) { value = v; return true; } - if (!TimeSpan.TryParse(currentValue.ToString(), out TimeSpan ts)) + if (!TimeSpan.TryParse(currentValue.ToString(), out var ts)) { value = default; return false; @@ -1637,7 +1920,7 @@ private bool TryGetRichStringValue(out T value) private static bool TryGetStringValue(out T value, object currentValue) { - if (typeof(T) == typeof(String)) + if (typeof(T) == typeof(string)) { var s = currentValue.ToString(); var matches = utfPattern.Matches(s); @@ -1663,7 +1946,9 @@ private static bool TryGetStringValue(out T value, object currentValue) } if (lastIndex < s.Length) + { sb.Append(s.Substring(lastIndex)); + } value = (T)Convert.ChangeType(sb.ToString(), typeof(T)); return true; @@ -1672,9 +1957,9 @@ private static bool TryGetStringValue(out T value, object currentValue) return false; } - private static Boolean TryGetBooleanValue(out T value, object currentValue) + private static bool TryGetBooleanValue(out T value, object currentValue) { - if (typeof(T) != typeof(Boolean) && typeof(T) != typeof(Boolean?)) + if (typeof(T) != typeof(bool) && typeof(T) != typeof(bool?)) { value = default; return false; @@ -1682,7 +1967,7 @@ private static Boolean TryGetBooleanValue(out T value, object currentValue) if (currentValue is T v) { value = v; return true; } - if (!Boolean.TryParse(currentValue.ToString(), out Boolean b)) + if (!bool.TryParse(currentValue.ToString(), out var b)) { value = default; return false; @@ -1692,7 +1977,7 @@ private static Boolean TryGetBooleanValue(out T value, object currentValue) return true; } - private Boolean TryGetHyperlink(out T value) + private bool TryGetHyperlink(out T value) { if (typeof(T) == typeof(XLHyperlink)) { @@ -1708,11 +1993,11 @@ private Boolean TryGetHyperlink(out T value) return false; } - private delegate Boolean ParseFunction(String s, NumberStyles style, IFormatProvider provider, out T result); + private delegate bool ParseFunction(string s, NumberStyles style, IFormatProvider provider, out T result); - private static Boolean TryGetBasicValue(String currentValue, ParseFunction parseFunction, out T value) + private static bool TryGetBasicValue(string currentValue, ParseFunction parseFunction, out T value) { - if (parseFunction.Invoke(currentValue, NumberStyles.Any, null, out U result)) + if (parseFunction.Invoke(currentValue, NumberStyles.Any, null, out var result)) { value = (T)Convert.ChangeType(result, typeof(T).GetUnderlyingType()); return true; @@ -1757,11 +2042,11 @@ public override IXLRanges RangesUsed #endregion IXLStylized Members - private Boolean SetTableHeaderValue(object value) + private bool SetTableHeaderValue(object value) { foreach (var table in Worksheet.Tables.Where(t => t.ShowHeaderRow)) { - var cell = table.HeadersRow().CellsUsed(c => c.Address.Equals(this.Address)).FirstOrDefault(); + var cell = table.HeadersRow().CellsUsed(c => c.Address.Equals(Address)).FirstOrDefault(); if (cell != null) { var oldName = cell.GetString(); @@ -1774,11 +2059,11 @@ private Boolean SetTableHeaderValue(object value) return false; } - private Boolean SetTableTotalsRowLabel(object value) + private bool SetTableTotalsRowLabel(object value) { foreach (var table in Worksheet.Tables.Where(t => t.ShowTotalsRow)) { - var cell = table.TotalsRow().Cells(c => c.Address.Equals(this.Address)).FirstOrDefault(); + var cell = table.TotalsRow().Cells(c => c.Address.Equals(Address)).FirstOrDefault(); if (cell != null) { var field = table.Fields.First(f => f.Column.ColumnNumber() == cell.WorksheetColumn().ColumnNumber()); @@ -1787,7 +2072,7 @@ private Boolean SetTableTotalsRowLabel(object value) SetInternalCellValueString(value.ObjectToInvariantString(), validate: true, parseToCachedValue: false); field.TotalsRowLabel = _cellValue; - this.DataType = XLDataType.Text; + DataType = XLDataType.Text; return true; } } @@ -1808,8 +2093,9 @@ private bool SetRangeColumns(object value) return true; } else - + { return SetColumns(value); + } } private bool SetColumns(object value) @@ -1825,7 +2111,9 @@ private bool SetColumns(object value) return true; } else + { return false; + } } private bool SetRangeRows(object value) @@ -1841,7 +2129,9 @@ private bool SetRangeRows(object value) return true; } else + { return SetRows(value); + } } private bool SetRows(object value) @@ -1857,7 +2147,9 @@ private bool SetRows(object value) return true; } else + { return false; + } } public XLRange AsRange() @@ -1877,7 +2169,7 @@ private void SetStyle(IXLStyle styleToUse) Style = styleToUse; } - public Boolean IsDefaultWorksheetStyle() + public bool IsDefaultWorksheetStyle() { return StyleValue == Worksheet.StyleValue; } @@ -1898,7 +2190,7 @@ private bool IsDateFormat() { var style = GetStyleForRead(); return _dataType == XLDataType.Number - && String.IsNullOrWhiteSpace(style.NumberFormat.Format) + && string.IsNullOrWhiteSpace(style.NumberFormat.Format) && ((style.NumberFormat.NumberFormatId >= 14 && style.NumberFormat.NumberFormatId <= 22) || (style.NumberFormat.NumberFormatId >= 45 @@ -1908,16 +2200,22 @@ private bool IsDateFormat() private string GetFormat() { var style = GetStyleForRead(); - if (String.IsNullOrWhiteSpace(style.NumberFormat.Format)) + if (string.IsNullOrWhiteSpace(style.NumberFormat.Format)) { var formatCodes = XLPredefinedFormat.FormatCodes; - if (formatCodes.TryGetValue(style.NumberFormat.NumberFormatId, out string format)) + if (formatCodes.TryGetValue(style.NumberFormat.NumberFormatId, out var format)) + { return format; + } else + { return string.Empty; + } } else + { return style.NumberFormat.Format; + } } private bool SetRichText(object value) @@ -1929,10 +2227,12 @@ private bool SetRichText(object value) return true; } else + { return false; + } } - private Boolean SetRange(Object rangeObject) + private bool SetRange(object rangeObject) { var asRange = (rangeObject as XLRangeBase) ?? (rangeObject as XLCell)?.AsRange(); @@ -2002,7 +2302,9 @@ private Boolean SetRange(Object rangeObject) newDataValidation.CopyFrom(dataValidation); } else + { newDataValidation.AddRange(dvTargetRange); + } } } @@ -2041,8 +2343,8 @@ private void CopyConditionalFormatsFrom(XLCell otherCell) private void CopyConditionalFormatsFrom(XLRangeBase fromRange) { var srcSheet = fromRange.Worksheet; - int minRo = fromRange.RangeAddress.FirstAddress.RowNumber; - int minCo = fromRange.RangeAddress.FirstAddress.ColumnNumber; + var minRo = fromRange.RangeAddress.FirstAddress.RowNumber; + var minCo = fromRange.RangeAddress.FirstAddress.ColumnNumber; if (srcSheet.ConditionalFormats.Any(r => r.Ranges.GetIntersectedRanges(fromRange.RangeAddress).Any())) { var fs = srcSheet.ConditionalFormats.SelectMany(cf => cf.Ranges.GetIntersectedRanges(fromRange.RangeAddress)).ToArray(); @@ -2052,8 +2354,8 @@ private void CopyConditionalFormatsFrom(XLRangeBase fromRange) minCo = fs.Max(r => r.RangeAddress.LastAddress.ColumnNumber); } } - int rCnt = minRo - fromRange.RangeAddress.FirstAddress.RowNumber + 1; - int cCnt = minCo - fromRange.RangeAddress.FirstAddress.ColumnNumber + 1; + var rCnt = minRo - fromRange.RangeAddress.FirstAddress.RowNumber + 1; + var cCnt = minCo - fromRange.RangeAddress.FirstAddress.ColumnNumber + 1; rCnt = Math.Min(rCnt, fromRange.RowCount()); cCnt = Math.Min(cCnt, fromRange.ColumnCount()); var toRange = Worksheet.Range(this, Worksheet.Cell(_rowNumber + rCnt - 1, _columnNumber + cCnt - 1)); @@ -2077,15 +2379,22 @@ private void CopyConditionalFormatsFrom(XLRangeBase fromRange) private bool SetDataTable(object o) { if (o is DataTable dataTable) + { return InsertData(dataTable) != null; + } else + { return false; + } } private bool SetEnumerable(object collectionObject) { // IXLRichText implements IEnumerable, but we don't want to handle this here. - if (collectionObject is IXLRichText) return false; + if (collectionObject is IXLRichText) + { + return false; + } var asEnumerable = collectionObject as IEnumerable; return InsertData(asEnumerable) != null; @@ -2093,7 +2402,7 @@ private bool SetEnumerable(object collectionObject) private void ClearMerged() { - List mergeToDelete = Worksheet.Internals.MergedRanges.GetIntersectedRanges(Address).ToList(); + var mergeToDelete = Worksheet.Internals.MergedRanges.GetIntersectedRanges(Address).ToList(); mergeToDelete.ForEach(m => Worksheet.Internals.MergedRanges.Remove(m)); } @@ -2102,17 +2411,16 @@ private void SetValue(object value) { if (value == null) { - this.Clear(XLClearOptions.Contents); + Clear(XLClearOptions.Contents); return; } - FormulaA1 = String.Empty; + FormulaA1 = string.Empty; _richText = null; var style = GetStyleForRead(); - Boolean parsed = false; - string parsedValue = string.Empty; - + bool parsed; + string parsedValue; //// // Try easy parsing first. If that doesn't work, we'll have to ToString it and parse it slowly @@ -2123,8 +2431,10 @@ private void SetValue(object value) parsedValue = value.ObjectToInvariantString(); _dataType = XLDataType.Text; - if (parsedValue.Contains(Environment.NewLine) && !style.Alignment.WrapText) + if (parsedValue.Contains(XLConstants.NewLine) && !style.Alignment.WrapText) + { Style.Alignment.WrapText = true; + } parsed = true; } @@ -2143,19 +2453,28 @@ private void SetValue(object value) parsedValue = DeduceCellValueByParsing(value.ToString(), style); } - if (SetTableHeaderValue(parsedValue)) return; - if (SetTableTotalsRowLabel(parsedValue)) return; + if (SetTableHeaderValue(parsedValue)) + { + return; + } + + if (SetTableTotalsRowLabel(parsedValue)) + { + return; + } SetInternalCellValueString(parsedValue, validate: true, parseToCachedValue: false); CachedValue = null; } - private void SetDateTimeFormat(XLStyleValue style, Boolean onlyDatePart) + private void SetDateTimeFormat(XLStyleValue style, bool onlyDatePart) { _dataType = XLDataType.DateTime; if (style.NumberFormat.Format.Length == 0 && style.NumberFormat.NumberFormatId == 0) + { Style.NumberFormat.NumberFormatId = onlyDatePart ? 14 : 22; + } } private void SetTimeSpanFormat(XLStyleValue style) @@ -2163,7 +2482,9 @@ private void SetTimeSpanFormat(XLStyleValue style) _dataType = XLDataType.TimeSpan; if (style.NumberFormat.Format.Length == 0 && style.NumberFormat.NumberFormatId == 0) + { Style.NumberFormat.NumberFormatId = 46; + } } internal string GetFormulaR1C1(string value) @@ -2179,8 +2500,10 @@ internal string GetFormulaA1(string value) private string GetFormula(string strValue, FormulaConversionType conversionType, int rowsToShift, int columnsToShift) { - if (String.IsNullOrWhiteSpace(strValue)) - return String.Empty; + if (string.IsNullOrWhiteSpace(strValue)) + { + return string.Empty; + } var value = ">" + strValue + "<"; @@ -2203,12 +2526,17 @@ private string GetFormula(string strValue, FormulaConversionType conversionType, : GetA1Address(matchString, rowsToShift, columnsToShift)); } else + { sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length)); + } + lastIndex = matchIndex + matchString.Length; } if (lastIndex < value.Length) + { sb.Append(value.Substring(lastIndex)); + } var retVal = sb.ToString(); return retVal.Substring(1, retVal.Length - 2); @@ -2260,7 +2588,9 @@ private string GetA1Column(string columnPart, int columnsToShift) { string columnToReturn; if (columnPart == "C") + { columnToReturn = XLHelper.GetColumnLetterFromNumber(_columnNumber + columnsToShift); + } else { var bIndex = columnPart.IndexOf("["); @@ -2269,19 +2599,19 @@ private string GetA1Column(string columnPart, int columnsToShift) { columnToReturn = XLHelper.GetColumnLetterFromNumber( _columnNumber + - Int32.Parse(columnPart.Substring(bIndex + 1, columnPart.Length - bIndex - 2)) + columnsToShift + int.Parse(columnPart.Substring(bIndex + 1, columnPart.Length - bIndex - 2)) + columnsToShift ); } else if (mIndex >= 0) { columnToReturn = XLHelper.GetColumnLetterFromNumber( - _columnNumber + Int32.Parse(columnPart.Substring(mIndex)) + columnsToShift + _columnNumber + int.Parse(columnPart.Substring(mIndex)) + columnsToShift ); } else { columnToReturn = "$" + - XLHelper.GetColumnLetterFromNumber(Int32.Parse(columnPart.Substring(1)) + + XLHelper.GetColumnLetterFromNumber(int.Parse(columnPart.Substring(1)) + columnsToShift); } } @@ -2293,18 +2623,22 @@ private string GetA1Row(string rowPart, int rowsToShift) { string rowToReturn; if (rowPart == "R") + { rowToReturn = (_rowNumber + rowsToShift).ToString(); + } else { var bIndex = rowPart.IndexOf("["); if (bIndex >= 0) { rowToReturn = - (_rowNumber + Int32.Parse(rowPart.Substring(bIndex + 1, rowPart.Length - bIndex - 2)) + + (_rowNumber + int.Parse(rowPart.Substring(bIndex + 1, rowPart.Length - bIndex - 2)) + rowsToShift).ToString(); } else - rowToReturn = "$" + (Int32.Parse(rowPart.Substring(1)) + rowsToShift); + { + rowToReturn = "$" + (int.Parse(rowPart.Substring(1)) + rowsToShift); + } } return rowToReturn; @@ -2317,9 +2651,9 @@ private string GetR1C1Address(string a1Address, int rowsToShift, int columnsToSh var parts = a1Address.Split(':'); var p1 = parts[0]; var p2 = parts[1]; - if (Int32.TryParse(p1.Replace("$", string.Empty), out Int32 row1)) + if (int.TryParse(p1.Replace("$", string.Empty), out var row1)) { - var row2 = Int32.Parse(p2.Replace("$", string.Empty)); + var row2 = int.Parse(p2.Replace("$", string.Empty)); var leftPart = GetR1C1Row(row1, p1.Contains('$'), rowsToShift); var rightPart = GetR1C1Row(row2, p2.Contains('$'), rowsToShift); return leftPart + ":" + rightPart; @@ -2348,9 +2682,13 @@ private string GetR1C1Row(int rowNumber, bool fixedRow, int rowsToShift) rowNumber += rowsToShift; var rowDiff = rowNumber - _rowNumber; if (rowDiff != 0 || fixedRow) + { rowPart = fixedRow ? "R" + rowNumber : "R[" + rowDiff + "]"; + } else + { rowPart = "R"; + } return rowPart; } @@ -2361,9 +2699,13 @@ private string GetR1C1Column(int columnNumber, bool fixedColumn, int columnsToSh columnNumber += columnsToShift; var columnDiff = columnNumber - _columnNumber; if (columnDiff != 0 || fixedColumn) + { columnPart = fixedColumn ? "C" + columnNumber : "C[" + columnDiff + "]"; + } else + { columnPart = "C"; + } return columnPart; } @@ -2383,41 +2725,59 @@ internal void CopyValuesFrom(XLCell source) } } - private IXLCell GetTargetCell(String target, XLWorksheet defaultWorksheet) + private IXLCell GetTargetCell(string target, XLWorksheet defaultWorksheet) { var pair = target.Split('!'); if (pair.Length == 1) + { return defaultWorksheet.Cell(target); + } var wsName = pair[0]; if (wsName.StartsWith("'")) + { wsName = wsName.Substring(1, wsName.Length - 2); + } + return defaultWorksheet.Workbook.Worksheet(wsName).Cell(pair[1]); } internal IXLCell CopyFromInternal(XLCell otherCell, XLCellCopyOptions options) { if (options.HasFlag(XLCellCopyOptions.Values)) + { CopyValuesFrom(otherCell); + } if (options.HasFlag(XLCellCopyOptions.Styles)) + { InnerStyle = otherCell.InnerStyle; + } if (options.HasFlag(XLCellCopyOptions.Sparklines)) + { CopySparklineFrom(otherCell); + } if (options.HasFlag(XLCellCopyOptions.ConditionalFormats)) + { CopyConditionalFormatsFrom(otherCell); + } if (options.HasFlag(XLCellCopyOptions.DataValidations)) + { CopyDataValidationFrom(otherCell); + } return this; } private void CopySparklineFrom(XLCell otherCell) { - if (!otherCell.HasSparkline) return; + if (!otherCell.HasSparkline) + { + return; + } var sourceDataAddress = otherCell.Sparkline.SourceData.RangeAddress.ToString(); var shiftedRangeAddress = GetFormulaA1(otherCell.GetFormulaR1C1(sourceDataAddress)); @@ -2462,7 +2822,9 @@ private void CopyDataValidationFrom(XLCell otherCell) var eventTracking = Worksheet.EventTrackingEnabled; Worksheet.EventTrackingEnabled = false; if (otherCell.HasDataValidation) + { CopyDataValidation(otherCell, otherCell.GetDataValidation()); + } else if (HasDataValidation) { Worksheet.DataValidations.Delete(AsRange()); @@ -2484,10 +2846,13 @@ internal void ShiftFormulaRows(XLRange shiftedRange, int rowsShifted) FormulaA1 = ShiftFormulaRows(FormulaA1, Worksheet, shiftedRange, rowsShifted); } - internal static String ShiftFormulaRows(String formulaA1, XLWorksheet worksheetInAction, XLRange shiftedRange, + internal static string ShiftFormulaRows(string formulaA1, XLWorksheet worksheetInAction, XLRange shiftedRange, int rowsShifted) { - if (String.IsNullOrWhiteSpace(formulaA1)) return String.Empty; + if (string.IsNullOrWhiteSpace(formulaA1)) + { + return string.Empty; + } var value = formulaA1; @@ -2511,13 +2876,18 @@ internal static String ShiftFormulaRows(String formulaA1, XLWorksheet worksheetI { sheetName = matchString.Substring(0, matchString.IndexOf('!')); if (sheetName[0] == '\'') + { sheetName = sheetName.Substring(1, sheetName.Length - 2); + } + useSheetName = true; } else + { sheetName = worksheetInAction.Name; + } - if (String.Compare(sheetName, shiftedWsName, true) == 0) + if (string.Compare(sheetName, shiftedWsName, true) == 0) { var rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1); if (!A1ColumnRegex.IsMatch(rangeAddress)) @@ -2542,19 +2912,23 @@ internal static String ShiftFormulaRows(String formulaA1, XLWorksheet worksheetI if (row1String[0] == '$') { row1 = "$" + - (XLHelper.TrimRowNumber(Int32.Parse(row1String.Substring(1)) + rowsShifted)).ToInvariantString(); + XLHelper.TrimRowNumber(int.Parse(row1String.Substring(1)) + rowsShifted).ToInvariantString(); } else - row1 = (XLHelper.TrimRowNumber(Int32.Parse(row1String) + rowsShifted)).ToInvariantString(); + { + row1 = XLHelper.TrimRowNumber(int.Parse(row1String) + rowsShifted).ToInvariantString(); + } string row2; if (row2String[0] == '$') { row2 = "$" + - (XLHelper.TrimRowNumber(Int32.Parse(row2String.Substring(1)) + rowsShifted)).ToInvariantString(); + XLHelper.TrimRowNumber(int.Parse(row2String.Substring(1)) + rowsShifted).ToInvariantString(); } else - row2 = (XLHelper.TrimRowNumber(Int32.Parse(row2String) + rowsShifted)).ToInvariantString(); + { + row2 = XLHelper.TrimRowNumber(int.Parse(row2String) + rowsShifted).ToInvariantString(); + } sb.Append(row1); sb.Append(':'); @@ -2606,22 +2980,32 @@ internal static String ShiftFormulaRows(String formulaA1, XLWorksheet worksheetI } } else + { sb.Append(matchString); + } } else + { sb.Append(matchString); + } } else + { sb.Append(matchString); + } } else + { sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length)); + } lastIndex = matchIndex + matchString.Length; } if (lastIndex < value.Length) + { sb.Append(value.Substring(lastIndex)); + } return sb.ToString(); } @@ -2631,10 +3015,13 @@ internal void ShiftFormulaColumns(XLRange shiftedRange, int columnsShifted) FormulaA1 = ShiftFormulaColumns(FormulaA1, Worksheet, shiftedRange, columnsShifted); } - internal static String ShiftFormulaColumns(String formulaA1, XLWorksheet worksheetInAction, XLRange shiftedRange, + internal static string ShiftFormulaColumns(string formulaA1, XLWorksheet worksheetInAction, XLRange shiftedRange, int columnsShifted) { - if (String.IsNullOrWhiteSpace(formulaA1)) return String.Empty; + if (string.IsNullOrWhiteSpace(formulaA1)) + { + return string.Empty; + } var value = formulaA1; @@ -2657,13 +3044,18 @@ internal static String ShiftFormulaColumns(String formulaA1, XLWorksheet workshe { sheetName = matchString.Substring(0, matchString.IndexOf('!')); if (sheetName[0] == '\'') + { sheetName = sheetName.Substring(1, sheetName.Length - 2); + } + useSheetName = true; } else + { sheetName = worksheetInAction.Name; + } - if (String.Compare(sheetName, shiftedRange.Worksheet.Name, true) == 0) + if (string.Compare(sheetName, shiftedRange.Worksheet.Name, true) == 0) { var rangeAddress = matchString.Substring(matchString.IndexOf('!') + 1); if (!A1RowRegex.IsMatch(rangeAddress)) @@ -2772,26 +3164,37 @@ internal static String ShiftFormulaColumns(String formulaA1, XLWorksheet workshe } } else + { sb.Append(matchString); + } } else + { sb.Append(matchString); + } } else + { sb.Append(matchString); + } } else + { sb.Append(value.Substring(lastIndex, matchIndex - lastIndex + matchString.Length)); + } + lastIndex = matchIndex + matchString.Length; } if (lastIndex < value.Length) + { sb.Append(value.Substring(lastIndex)); + } return sb.ToString(); } - private XLCell CellShift(Int32 rowsToShift, Int32 columnsToShift) + private XLCell CellShift(int rowsToShift, int columnsToShift) { return Worksheet.Cell(_rowNumber + rowsToShift, _columnNumber + columnsToShift); } @@ -2813,7 +3216,7 @@ IXLCell IXLCell.CellAbove() return CellAbove(); } - IXLCell IXLCell.CellAbove(Int32 step) + IXLCell IXLCell.CellAbove(int step) { return CellAbove(step); } @@ -2823,7 +3226,7 @@ public XLCell CellAbove() return CellAbove(1); } - public XLCell CellAbove(Int32 step) + public XLCell CellAbove(int step) { return CellShift(step * -1, 0); } @@ -2837,7 +3240,7 @@ IXLCell IXLCell.CellBelow() return CellBelow(); } - IXLCell IXLCell.CellBelow(Int32 step) + IXLCell IXLCell.CellBelow(int step) { return CellBelow(step); } @@ -2847,7 +3250,7 @@ public XLCell CellBelow() return CellBelow(1); } - public XLCell CellBelow(Int32 step) + public XLCell CellBelow(int step) { return CellShift(step, 0); } @@ -2861,7 +3264,7 @@ IXLCell IXLCell.CellLeft() return CellLeft(); } - IXLCell IXLCell.CellLeft(Int32 step) + IXLCell IXLCell.CellLeft(int step) { return CellLeft(step); } @@ -2871,7 +3274,7 @@ public XLCell CellLeft() return CellLeft(1); } - public XLCell CellLeft(Int32 step) + public XLCell CellLeft(int step) { return CellShift(0, step * -1); } @@ -2885,7 +3288,7 @@ IXLCell IXLCell.CellRight() return CellRight(); } - IXLCell IXLCell.CellRight(Int32 step) + IXLCell IXLCell.CellRight(int step) { return CellRight(step); } @@ -2895,26 +3298,20 @@ public XLCell CellRight() return CellRight(1); } - public XLCell CellRight(Int32 step) + public XLCell CellRight(int step) { return CellShift(0, step); } #endregion XLCell Right - public Boolean HasFormula { get { return !String.IsNullOrWhiteSpace(FormulaA1); } } + public bool HasFormula => !string.IsNullOrWhiteSpace(FormulaA1); - public Boolean HasArrayFormula { get { return FormulaA1.StartsWith("{"); } } + public bool HasArrayFormula => FormulaA1.StartsWith("{"); public IXLRangeAddress FormulaReference { get; set; } - public IXLRange CurrentRegion - { - get - { - return this.Worksheet.Range(FindCurrentRegion(this.AsRange())); - } - } + public IXLRange CurrentRegion => Worksheet.Range(FindCurrentRegion(AsRange())); internal IXLRangeAddress FindCurrentRegion(IXLRangeBase range) { @@ -2922,27 +3319,31 @@ internal IXLRangeAddress FindCurrentRegion(IXLRangeBase range) var filledCells = range .SurroundingCells(c => !(c as XLCell).IsEmpty(XLCellsUsedOptions.AllContents)) - .Concat(this.Worksheet.Range(rangeAddress).Cells()); + .Concat(Worksheet.Range(rangeAddress).Cells()); var grownRangeAddress = new XLRangeAddress( - new XLAddress(this.Worksheet, filledCells.Min(c => c.Address.RowNumber), filledCells.Min(c => c.Address.ColumnNumber), false, false), - new XLAddress(this.Worksheet, filledCells.Max(c => c.Address.RowNumber), filledCells.Max(c => c.Address.ColumnNumber), false, false) + new XLAddress(Worksheet, filledCells.Min(c => c.Address.RowNumber), filledCells.Min(c => c.Address.ColumnNumber), false, false), + new XLAddress(Worksheet, filledCells.Max(c => c.Address.RowNumber), filledCells.Max(c => c.Address.ColumnNumber), false, false) ); if (rangeAddress.Equals(grownRangeAddress)) - return this.Worksheet.Range(grownRangeAddress).RangeAddress; + { + return Worksheet.Range(grownRangeAddress).RangeAddress; + } else - return FindCurrentRegion(this.Worksheet.Range(grownRangeAddress)); + { + return FindCurrentRegion(Worksheet.Range(grownRangeAddress)); + } } internal bool IsInferiorMergedCell() { - return this.IsMerged() && !this.Address.Equals(this.MergedRange().RangeAddress.FirstAddress); + return IsMerged() && !Address.Equals(MergedRange().RangeAddress.FirstAddress); } internal bool IsSuperiorMergedCell() { - return this.IsMerged() && this.Address.Equals(this.MergedRange().RangeAddress.FirstAddress); + return IsMerged() && Address.Equals(MergedRange().RangeAddress.FirstAddress); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Cells/XLCells.cs b/ClosedXML/Excel/Cells/XLCells.cs index e91501e9b..3b7c2e265 100644 --- a/ClosedXML/Excel/Cells/XLCells.cs +++ b/ClosedXML/Excel/Cells/XLCells.cs @@ -1,26 +1,26 @@ +using ClosedXML.Excel.Style; using System; using System.Collections; using System.Collections.Generic; +using System.Linq; namespace ClosedXML.Excel { - using System.Linq; - internal class XLCells : XLStylizedBase, IXLCells, IXLStylized, IEnumerable { #region Fields private readonly List _rangeAddresses = new List(); private readonly bool _usedCellsOnly; - private readonly Func _predicate; + private readonly Func _predicate; private readonly XLCellsUsedOptions _options; - private bool _styleInitialized = false; + private bool _styleInitialized; #endregion Fields #region Constructor - public XLCells(bool usedCellsOnly, XLCellsUsedOptions options, Func predicate = null) + public XLCells(bool usedCellsOnly, XLCellsUsedOptions options, Func predicate = null) : base(XLStyle.Default.Value) { _usedCellsOnly = usedCellsOnly; @@ -44,7 +44,9 @@ private IEnumerable GetAllCells() { var c = ws.Cell(sheetPoint.Row, sheetPoint.Column); if (_predicate(c)) + { yield return c; + } } } } @@ -52,7 +54,9 @@ private IEnumerable GetAllCells() private IEnumerable GetAllCellsInRange(IXLRangeAddress rangeAddress) { if (!rangeAddress.IsValid) + { yield break; + } var normalizedAddress = ((XLRangeAddress)rangeAddress).Normalize(); var minRow = normalizedAddress.FirstAddress.RowNumber; @@ -85,7 +89,10 @@ private IEnumerable GetUsedCells() var visitedCells = new HashSet(); foreach (var cell in cells) { - if (visitedCells.Contains(cell.Address)) continue; + if (visitedCells.Contains(cell.Address)) + { + continue; + } visitedCells.Add(cell.Address); @@ -97,7 +104,10 @@ private IEnumerable GetUsedCells() private IEnumerable GetUsedCellsInRange(XLRangeAddress rangeAddress, XLWorksheet worksheet, IEnumerable usedCellsCandidates) { if (!rangeAddress.IsValid) + { yield break; + } + var normalizedAddress = rangeAddress.Normalize(); var minRow = normalizedAddress.FirstAddress.RowNumber; var maxRow = normalizedAddress.LastAddress.RowNumber; @@ -111,7 +121,9 @@ private IEnumerable GetUsedCellsInRange(XLRangeAddress rangeAddress, XLW foreach (var cell in cellRange) { if (_predicate(cell)) + { yield return cell; + } } foreach (var sheetPoint in usedCellsCandidates) @@ -122,7 +134,9 @@ private IEnumerable GetUsedCellsInRange(XLRangeAddress rangeAddress, XLW var cell = worksheet.Cell(sheetPoint.Row, sheetPoint.Column); if (_predicate(cell)) + { yield return cell; + } } } } @@ -132,23 +146,29 @@ private IEnumerable GetUsedCellsCandidates(XLWorksheet worksheet) var candidates = Enumerable.Empty(); if (_options.HasFlag(XLCellsUsedOptions.MergedRanges)) + { candidates = candidates.Union( worksheet.Internals.MergedRanges.SelectMany(r => GetAllCellsInRange(r.RangeAddress))); + } if (_options.HasFlag(XLCellsUsedOptions.ConditionalFormats)) + { candidates = candidates.Union( worksheet.ConditionalFormats.SelectMany(cf => cf.Ranges.SelectMany(r => GetAllCellsInRange(r.RangeAddress)))); + } if (_options.HasFlag(XLCellsUsedOptions.DataValidation)) + { candidates = candidates.Union( worksheet.DataValidations.SelectMany(dv => dv.Ranges.SelectMany(r => GetAllCellsInRange(r.RangeAddress)))); + } return candidates.Distinct(); } public IEnumerator GetEnumerator() { - var cells = (_usedCellsOnly) ? GetUsedCells() : GetAllCells(); + var cells = _usedCellsOnly ? GetUsedCells() : GetAllCells(); foreach (var cell in cells) { yield return cell; @@ -161,8 +181,10 @@ public IEnumerator GetEnumerator() IEnumerator IEnumerable.GetEnumerator() { - foreach (XLCell cell in this) + foreach (var cell in this) + { yield return cell; + } } IEnumerator IEnumerable.GetEnumerator() @@ -170,7 +192,7 @@ IEnumerator IEnumerable.GetEnumerator() return GetEnumerator(); } - public Object Value + public object Value { set { this.ForEach(c => c.Value = value); } } @@ -202,12 +224,12 @@ public void DeleteSparklines() this.ForEach(c => c.DeleteSparkline()); } - public String FormulaA1 + public string FormulaA1 { set { this.ForEach(c => c.FormulaA1 = value); } } - public String FormulaR1C1 + public string FormulaR1C1 { set { this.ForEach(c => c.FormulaR1C1 = value); } } @@ -221,8 +243,10 @@ public override IEnumerable Styles get { yield return Style; - foreach (XLCell c in this) + foreach (var c in this) + { yield return c.Style; + } } } @@ -230,8 +254,10 @@ protected override IEnumerable Children { get { - foreach (XLCell c in this) + foreach (var c in this) + { yield return c; + } } } @@ -252,11 +278,15 @@ public void Add(XLRangeAddress rangeAddress) _rangeAddresses.Add(rangeAddress); if (_styleInitialized) + { return; + } var worksheetStyle = rangeAddress.Worksheet?.Style; if (worksheetStyle == null) + { return; + } InnerStyle = worksheetStyle; _styleInitialized = true; @@ -270,7 +300,9 @@ public void Add(XLCell cell) public void Select() { foreach (var cell in this) + { cell.Select(); + } } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Cells/XLCellsCollection.cs b/ClosedXML/Excel/Cells/XLCellsCollection.cs index ef56b993a..580602ebd 100644 --- a/ClosedXML/Excel/Cells/XLCellsCollection.cs +++ b/ClosedXML/Excel/Cells/XLCellsCollection.cs @@ -6,60 +6,76 @@ namespace ClosedXML.Excel { internal class XLCellsCollection { - internal Dictionary ColumnsUsed { get; } = new Dictionary(); - internal Dictionary> Deleted { get; } = new Dictionary>(); + internal Dictionary ColumnsUsed { get; } = new Dictionary(); + internal Dictionary> Deleted { get; } = new Dictionary>(); internal Dictionary> RowsCollection { get; } = new Dictionary>(); - public Int32 MaxColumnUsed; - public Int32 MaxRowUsed; - public Dictionary RowsUsed = new Dictionary(); + public int MaxColumnUsed; + public int MaxRowUsed; + public Dictionary RowsUsed = new Dictionary(); public XLCellsCollection() { Clear(); } - public Int32 Count { get; private set; } + public int Count { get; private set; } public void Add(XLSheetPoint sheetPoint, XLCell cell) { Add(sheetPoint.Row, sheetPoint.Column, cell); } - public void Add(Int32 row, Int32 column, XLCell cell) + public void Add(int row, int column, XLCell cell) { Count++; IncrementUsage(RowsUsed, row); IncrementUsage(ColumnsUsed, column); - if (!RowsCollection.TryGetValue(row, out Dictionary columnsCollection)) + if (!RowsCollection.TryGetValue(row, out var columnsCollection)) { columnsCollection = new Dictionary(); RowsCollection.Add(row, columnsCollection); } columnsCollection.Add(column, cell); - if (row > MaxRowUsed) MaxRowUsed = row; - if (column > MaxColumnUsed) MaxColumnUsed = column; + if (row > MaxRowUsed) + { + MaxRowUsed = row; + } - if (Deleted.TryGetValue(row, out HashSet delHash)) + if (column > MaxColumnUsed) + { + MaxColumnUsed = column; + } + + if (Deleted.TryGetValue(row, out var delHash)) + { delHash.Remove(column); + } } - private static void IncrementUsage(Dictionary dictionary, Int32 key) + private static void IncrementUsage(Dictionary dictionary, int key) { - if (dictionary.TryGetValue(key, out Int32 value)) + if (dictionary.TryGetValue(key, out var value)) + { dictionary[key] = value + 1; + } else + { dictionary.Add(key, 1); + } } /// /// True if the number was lowered to zero so MaxColumnUsed or MaxRowUsed may require /// recomputation. - private static bool DecrementUsage(Dictionary dictionary, Int32 key) + private static bool DecrementUsage(Dictionary dictionary, int key) { - if (!dictionary.TryGetValue(key, out Int32 count)) return false; + if (!dictionary.TryGetValue(key, out var count)) + { + return false; + } if (count > 1) { @@ -89,7 +105,7 @@ public void Remove(XLSheetPoint sheetPoint) Remove(sheetPoint.Row, sheetPoint.Column); } - public void Remove(Int32 row, Int32 column) + public void Remove(int row, int column) { Count--; var rowRemoved = DecrementUsage(RowsUsed, row); @@ -109,19 +125,23 @@ public void Remove(Int32 row, Int32 column) : 0; } - if (Deleted.TryGetValue(row, out HashSet delHash)) + if (Deleted.TryGetValue(row, out var delHash)) { if (!delHash.Contains(column)) + { delHash.Add(column); + } } else { - delHash = new HashSet(); - delHash.Add(column); + delHash = new HashSet + { + column + }; Deleted.Add(row, delHash); } - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(row, out var columnsCollection)) { columnsCollection.Remove(column); if (columnsCollection.Count == 0) @@ -131,42 +151,45 @@ public void Remove(Int32 row, Int32 column) } } - internal IEnumerable GetCells(Int32 rowStart, Int32 columnStart, - Int32 rowEnd, Int32 columnEnd, - Func predicate = null) + internal IEnumerable GetCells(int rowStart, int columnStart, + int rowEnd, int columnEnd, + Func predicate = null) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = rowStart; ro <= finalRow; ro++) + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = rowStart; ro <= finalRow; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = columnStart; co <= finalColumn; co++) + for (var co = columnStart; co <= finalColumn; co++) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && (predicate == null || predicate(cell))) + { yield return cell; + } } } } } public int FirstRowUsed(int rowStart, int columnStart, int rowEnd, int columnEnd, XLCellsUsedOptions options, - Func predicate = null) + Func predicate = null) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = rowStart; ro <= finalRow; ro++) + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = rowStart; ro <= finalRow; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = columnStart; co <= finalColumn; co++) + for (var co = columnStart; co <= finalColumn; co++) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && !cell.IsEmpty(options) && (predicate == null || predicate(cell))) - + { return ro; + } } } } @@ -175,19 +198,19 @@ public int FirstRowUsed(int rowStart, int columnStart, int rowEnd, int columnEnd } public int FirstColumnUsed(int rowStart, int columnStart, int rowEnd, int columnEnd, XLCellsUsedOptions options, - Func predicate = null) + Func predicate = null) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - int firstColumnUsed = finalColumn; + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + var firstColumnUsed = finalColumn; var found = false; - for (int ro = rowStart; ro <= finalRow; ro++) + for (var ro = rowStart; ro <= finalRow; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = columnStart; co <= firstColumnUsed; co++) + for (var co = columnStart; co <= firstColumnUsed; co++) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && !cell.IsEmpty(options) && (predicate == null || predicate(cell)) && co <= firstColumnUsed) @@ -204,21 +227,22 @@ public int FirstColumnUsed(int rowStart, int columnStart, int rowEnd, int column } public int LastRowUsed(int rowStart, int columnStart, int rowEnd, int columnEnd, XLCellsUsedOptions options, - Func predicate = null) + Func predicate = null) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = finalRow; ro >= rowStart; ro--) + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = finalRow; ro >= rowStart; ro--) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = finalColumn; co >= columnStart; co--) + for (var co = finalColumn; co >= columnStart; co--) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && !cell.IsEmpty(options) && (predicate == null || predicate(cell))) - + { return ro; + } } } } @@ -226,72 +250,79 @@ public int LastRowUsed(int rowStart, int columnStart, int rowEnd, int columnEnd, } public int LastColumnUsed(int rowStart, int columnStart, int rowEnd, int columnEnd, XLCellsUsedOptions options, - Func predicate = null) + Func predicate = null) { - int maxCo = 0; - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = finalRow; ro >= rowStart; ro--) + var maxCo = 0; + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = finalRow; ro >= rowStart; ro--) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = finalColumn; co >= columnStart && co > maxCo; co--) + for (var co = finalColumn; co >= columnStart && co > maxCo; co--) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && !cell.IsEmpty(options) && (predicate == null || predicate(cell))) - + { maxCo = co; + } } } } return maxCo; } - public void RemoveAll(Int32 rowStart, Int32 columnStart, - Int32 rowEnd, Int32 columnEnd) + public void RemoveAll(int rowStart, int columnStart, + int rowEnd, int columnEnd) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = rowStart; ro <= finalRow; ro++) + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = rowStart; ro <= finalRow; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = columnStart; co <= finalColumn; co++) + for (var co = columnStart; co <= finalColumn; co++) { if (columnsCollection.ContainsKey(co)) + { Remove(ro, co); + } } } } } - public IEnumerable GetSheetPoints(Int32 rowStart, Int32 columnStart, - Int32 rowEnd, Int32 columnEnd) + public IEnumerable GetSheetPoints(int rowStart, int columnStart, + int rowEnd, int columnEnd) { - int finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; - int finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; - for (int ro = rowStart; ro <= finalRow; ro++) + var finalRow = rowEnd > MaxRowUsed ? MaxRowUsed : rowEnd; + var finalColumn = columnEnd > MaxColumnUsed ? MaxColumnUsed : columnEnd; + for (var ro = rowStart; ro <= finalRow; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = columnStart; co <= finalColumn; co++) + for (var co = columnStart; co <= finalColumn; co++) { if (columnsCollection.ContainsKey(co)) + { yield return new XLSheetPoint(ro, co); + } } } } } - public XLCell GetCell(Int32 row, Int32 column) + public XLCell GetCell(int row, int column) { if (row > MaxRowUsed || column > MaxColumnUsed) + { return null; + } - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(row, out var columnsCollection)) { - return columnsCollection.TryGetValue(column, out XLCell cell) ? cell : null; + return columnsCollection.TryGetValue(column, out var cell) ? cell : null; } return null; } @@ -303,19 +334,26 @@ public XLCell GetCell(XLSheetPoint sp) internal void SwapRanges(XLSheetRange sheetRange1, XLSheetRange sheetRange2, XLWorksheet worksheet) { - Int32 rowCount = sheetRange1.LastPoint.Row - sheetRange1.FirstPoint.Row + 1; - Int32 columnCount = sheetRange1.LastPoint.Column - sheetRange1.FirstPoint.Column + 1; - for (int row = 0; row < rowCount; row++) + var rowCount = sheetRange1.LastPoint.Row - sheetRange1.FirstPoint.Row + 1; + var columnCount = sheetRange1.LastPoint.Column - sheetRange1.FirstPoint.Column + 1; + for (var row = 0; row < rowCount; row++) { - for (int column = 0; column < columnCount; column++) + for (var column = 0; column < columnCount; column++) { var sp1 = new XLSheetPoint(sheetRange1.FirstPoint.Row + row, sheetRange1.FirstPoint.Column + column); var sp2 = new XLSheetPoint(sheetRange2.FirstPoint.Row + row, sheetRange2.FirstPoint.Column + column); var cell1 = GetCell(sp1); var cell2 = GetCell(sp2); - if (cell1 == null) cell1 = worksheet.Cell(sp1.Row, sp1.Column); - if (cell2 == null) cell2 = worksheet.Cell(sp2.Row, sp2.Column); + if (cell1 == null) + { + cell1 = worksheet.Cell(sp1.Row, sp1.Column); + } + + if (cell2 == null) + { + cell2 = worksheet.Cell(sp2.Row, sp2.Column); + } //if (cell1 != null) //{ @@ -340,82 +378,88 @@ internal IEnumerable GetCells() return GetCells(1, 1, MaxRowUsed, MaxColumnUsed); } - internal IEnumerable GetCells(Func predicate) + internal IEnumerable GetCells(Func predicate) { - for (int ro = 1; ro <= MaxRowUsed; ro++) + for (var ro = 1; ro <= MaxRowUsed; ro++) { - if (RowsCollection.TryGetValue(ro, out Dictionary columnsCollection)) + if (RowsCollection.TryGetValue(ro, out var columnsCollection)) { - for (int co = 1; co <= MaxColumnUsed; co++) + for (var co = 1; co <= MaxColumnUsed; co++) { - if (columnsCollection.TryGetValue(co, out XLCell cell) + if (columnsCollection.TryGetValue(co, out var cell) && (predicate == null || predicate(cell))) + { yield return cell; + } } } } } - public Boolean Contains(Int32 row, Int32 column) + public bool Contains(int row, int column) { - return RowsCollection.TryGetValue(row, out Dictionary columnsCollection) + return RowsCollection.TryGetValue(row, out var columnsCollection) && columnsCollection.ContainsKey(column); } - public Int32 MinRowInColumn(Int32 column) + public int MinRowInColumn(int column) { - for (int row = 1; row <= MaxRowUsed; row++) + for (var row = 1; row <= MaxRowUsed; row++) { - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection) + if (RowsCollection.TryGetValue(row, out var columnsCollection) && columnsCollection.ContainsKey(column)) - + { return row; + } } return 0; } - public Int32 MaxRowInColumn(Int32 column) + public int MaxRowInColumn(int column) { - for (int row = MaxRowUsed; row >= 1; row--) + for (var row = MaxRowUsed; row >= 1; row--) { - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection) + if (RowsCollection.TryGetValue(row, out var columnsCollection) && columnsCollection.ContainsKey(column)) - + { return row; + } } return 0; } - public Int32 MinColumnInRow(Int32 row) + public int MinColumnInRow(int row) { - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection) + if (RowsCollection.TryGetValue(row, out var columnsCollection) && columnsCollection.Any()) - + { return columnsCollection.Keys.Min(); + } return 0; } - public Int32 MaxColumnInRow(Int32 row) + public int MaxColumnInRow(int row) { - if (RowsCollection.TryGetValue(row, out Dictionary columnsCollection) + if (RowsCollection.TryGetValue(row, out var columnsCollection) && columnsCollection.Any()) - + { return columnsCollection.Keys.Max(); + } return 0; } - public IEnumerable GetCellsInColumn(Int32 column) + public IEnumerable GetCellsInColumn(int column) { return GetCells(1, column, MaxRowUsed, column); } - public IEnumerable GetCellsInRow(Int32 row) + public IEnumerable GetCellsInRow(int row) { return GetCells(row, 1, row, MaxColumnUsed); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Charts/IXLChart.cs b/ClosedXML/Excel/Charts/IXLChart.cs index 7cfc8139f..087a70f0e 100644 --- a/ClosedXML/Excel/Charts/IXLChart.cs +++ b/ClosedXML/Excel/Charts/IXLChart.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLChartType { @@ -79,9 +77,9 @@ public enum XLChartType { } public interface IXLChart: IXLDrawing { - Boolean RightAngleAxes { get; set; } + bool RightAngleAxes { get; set; } IXLChart SetRightAngleAxes(); - IXLChart SetRightAngleAxes(Boolean rightAngleAxes); + IXLChart SetRightAngleAxes(bool rightAngleAxes); XLChartType ChartType { get; set; } IXLChart SetChartType(XLChartType chartType); diff --git a/ClosedXML/Excel/Charts/XLChart.cs b/ClosedXML/Excel/Charts/XLChart.cs index d928e6ccc..053f15dff 100644 --- a/ClosedXML/Excel/Charts/XLChart.cs +++ b/ClosedXML/Excel/Charts/XLChart.cs @@ -14,23 +14,28 @@ public XLChart(XLWorksheet worksheet) { Container = this; this.worksheet = worksheet; - Int32 zOrder; + int zOrder; if (worksheet.Charts.Any()) + { zOrder = worksheet.Charts.Max(c => c.ZOrder) + 1; + } else + { zOrder = 1; + } + ZOrder = zOrder; ShapeId = worksheet.Workbook.ShapeIdManager.GetNext(); RightAngleAxes = true; } - public Boolean RightAngleAxes { get; set; } + public bool RightAngleAxes { get; set; } public IXLChart SetRightAngleAxes() { RightAngleAxes = true; return this; } - public IXLChart SetRightAngleAxes(Boolean rightAngleAxes) + public IXLChart SetRightAngleAxes(bool rightAngleAxes) { RightAngleAxes = rightAngleAxes; return this; @@ -48,14 +53,17 @@ public XLChartTypeCategory ChartTypeCategory get { if (Bar3DCharts.Contains(ChartType)) + { return XLChartTypeCategory.Bar3D; + } else + { throw new NotImplementedException(); - + } } } - private HashSet Bar3DCharts = new HashSet { + private readonly HashSet Bar3DCharts = new HashSet { XLChartType.BarClustered3D, XLChartType.BarStacked100Percent3D, XLChartType.BarStacked3D, @@ -70,13 +78,17 @@ public XLBarOrientation BarOrientation get { if (HorizontalCharts.Contains(ChartType)) + { return XLBarOrientation.Horizontal; + } else + { return XLBarOrientation.Vertical; + } } } - private HashSet HorizontalCharts = new HashSet{ + private readonly HashSet HorizontalCharts = new HashSet{ XLChartType.BarClustered, XLChartType.BarClustered3D, XLChartType.BarStacked, @@ -99,13 +111,21 @@ public XLBarGrouping BarGrouping get { if (ClusteredCharts.Contains(ChartType)) + { return XLBarGrouping.Clustered; + } else if (PercentCharts.Contains(ChartType)) + { return XLBarGrouping.Percent; + } else if (StackedCharts.Contains(ChartType)) + { return XLBarGrouping.Stacked; + } else + { return XLBarGrouping.Standard; + } } } diff --git a/ClosedXML/Excel/Charts/XLCharts.cs b/ClosedXML/Excel/Charts/XLCharts.cs index 112a6fc9d..d5839cecf 100644 --- a/ClosedXML/Excel/Charts/XLCharts.cs +++ b/ClosedXML/Excel/Charts/XLCharts.cs @@ -2,9 +2,10 @@ namespace ClosedXML.Excel { - internal class XLCharts: IXLCharts + internal class XLCharts : IXLCharts { - private List charts = new List(); + private readonly List charts = new List(); + public IEnumerator GetEnumerator() { return charts.GetEnumerator(); @@ -20,4 +21,4 @@ public void Add(IXLChart chart) charts.Add(chart); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Columns/IXLColumn.cs b/ClosedXML/Excel/Columns/IXLColumn.cs index db2aecbbf..90c3a9b76 100644 --- a/ClosedXML/Excel/Columns/IXLColumn.cs +++ b/ClosedXML/Excel/Columns/IXLColumn.cs @@ -10,7 +10,7 @@ public interface IXLColumn : IXLRangeBase /// /// The width of this column. /// - Double Width { get; set; } + double Width { get; set; } /// /// Deletes this column and shifts the columns at the right of this one accordingly. @@ -20,46 +20,46 @@ public interface IXLColumn : IXLRangeBase /// /// Gets this column's number /// - Int32 ColumnNumber(); + int ColumnNumber(); /// /// Gets this column's letter /// - String ColumnLetter(); + string ColumnLetter(); /// /// Inserts X number of columns at the right of this one. /// All columns at the right will be shifted accordingly. /// /// The number of columns to insert. - IXLColumns InsertColumnsAfter(Int32 numberOfColumns); + IXLColumns InsertColumnsAfter(int numberOfColumns); /// /// Inserts X number of columns at the left of this one. /// This column and all at the right will be shifted accordingly. /// /// The number of columns to insert. - IXLColumns InsertColumnsBefore(Int32 numberOfColumns); + IXLColumns InsertColumnsBefore(int numberOfColumns); /// /// Gets the cell in the specified row. /// /// The cell's row. - IXLCell Cell(Int32 rowNumber); + IXLCell Cell(int rowNumber); /// /// Returns the specified group of cells, separated by commas. /// e.g. Cells("1"), Cells("1:5"), Cells("1,3:5") /// /// The column cells to return. - new IXLCells Cells(String cellsInColumn); + new IXLCells Cells(string cellsInColumn); /// /// Returns the specified group of cells. /// /// The first row in the group of cells to return. /// The last row in the group of cells to return. - IXLCells Cells(Int32 firstRow, Int32 lastRow); + IXLCells Cells(int firstRow, int lastRow); /// /// Adjusts the width of the column based on its contents. @@ -70,20 +70,20 @@ public interface IXLColumn : IXLRangeBase /// Adjusts the width of the column based on its contents, starting from the startRow. /// /// The row to start calculating the column width. - IXLColumn AdjustToContents(Int32 startRow); + IXLColumn AdjustToContents(int startRow); /// /// Adjusts the width of the column based on its contents, starting from the startRow and ending at endRow. /// /// The row to start calculating the column width. /// The row to end calculating the column width. - IXLColumn AdjustToContents(Int32 startRow, Int32 endRow); + IXLColumn AdjustToContents(int startRow, int endRow); - IXLColumn AdjustToContents(Double minWidth, Double maxWidth); + IXLColumn AdjustToContents(double minWidth, double maxWidth); - IXLColumn AdjustToContents(Int32 startRow, Double minWidth, Double maxWidth); + IXLColumn AdjustToContents(int startRow, double minWidth, double maxWidth); - IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, Double maxWidth); + IXLColumn AdjustToContents(int startRow, int endRow, double minWidth, double maxWidth); /// /// Hides this column. @@ -99,7 +99,7 @@ public interface IXLColumn : IXLRangeBase /// /// true if this column is hidden; otherwise, false. /// - Boolean IsHidden { get; } + bool IsHidden { get; } /// /// Gets or sets the outline level of this column. @@ -107,7 +107,7 @@ public interface IXLColumn : IXLRangeBase /// /// The outline level of this column. /// - Int32 OutlineLevel { get; set; } + int OutlineLevel { get; set; } /// /// Adds this column to the next outline level (Increments the outline level for this column by 1). @@ -118,20 +118,20 @@ public interface IXLColumn : IXLRangeBase /// Adds this column to the next outline level (Increments the outline level for this column by 1). /// /// If set to true the column will be shown collapsed. - IXLColumn Group(Boolean collapse); + IXLColumn Group(bool collapse); /// /// Sets outline level for this column. /// /// The outline level. - IXLColumn Group(Int32 outlineLevel); + IXLColumn Group(int outlineLevel); /// /// Sets outline level for this column. /// /// The outline level. /// If set to true the column will be shown collapsed. - IXLColumn Group(Int32 outlineLevel, Boolean collapse); + IXLColumn Group(int outlineLevel, bool collapse); /// /// Adds this column to the previous outline level (decrements the outline level for this column by 1). @@ -142,7 +142,7 @@ public interface IXLColumn : IXLRangeBase /// Adds this column to the previous outline level (decrements the outline level for this column by 1). /// /// If set to true it will remove this column from all outline levels. - IXLColumn Ungroup(Boolean fromAll); + IXLColumn Ungroup(bool fromAll); /// /// Show this column as collapsed. @@ -152,7 +152,7 @@ public interface IXLColumn : IXLRangeBase /// Expands this column (if it's collapsed). IXLColumn Expand(); - Int32 CellCount(); + int CellCount(); IXLRangeColumn CopyTo(IXLCell cell); @@ -160,13 +160,13 @@ public interface IXLColumn : IXLRangeBase IXLColumn CopyTo(IXLColumn column); - IXLColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRangeColumn Column(Int32 start, Int32 end); + IXLRangeColumn Column(int start, int end); IXLRangeColumn Column(IXLCell start, IXLCell end); - IXLRangeColumns Columns(String columns); + IXLRangeColumns Columns(string columns); /// /// Adds a vertical page break after this column. @@ -177,11 +177,11 @@ public interface IXLColumn : IXLRangeBase IXLColumn ColumnLeft(); - IXLColumn ColumnLeft(Int32 step); + IXLColumn ColumnLeft(int step); IXLColumn ColumnRight(); - IXLColumn ColumnRight(Int32 step); + IXLColumn ColumnRight(int step); /// /// Clears the contents of this column. @@ -190,8 +190,8 @@ public interface IXLColumn : IXLRangeBase new IXLColumn Clear(XLClearOptions clearOptions = XLClearOptions.All); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn ColumnUsed(Boolean includeFormats); + IXLRangeColumn ColumnUsed(bool includeFormats); IXLRangeColumn ColumnUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Columns/IXLColumns.cs b/ClosedXML/Excel/Columns/IXLColumns.cs index 56a8edf1c..845f9d2e1 100644 --- a/ClosedXML/Excel/Columns/IXLColumns.cs +++ b/ClosedXML/Excel/Columns/IXLColumns.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -11,7 +10,7 @@ public interface IXLColumns : IEnumerable /// /// The width of all columns. /// - Double Width { set; } + double Width { set; } /// /// Deletes all columns and shifts the columns at the right of them accordingly. @@ -27,20 +26,20 @@ public interface IXLColumns : IEnumerable /// Adjusts the width of all columns based on its contents, starting from the startRow. /// /// The row to start calculating the column width. - IXLColumns AdjustToContents(Int32 startRow); + IXLColumns AdjustToContents(int startRow); /// /// Adjusts the width of all columns based on its contents, starting from the startRow and ending at endRow. /// /// The row to start calculating the column width. /// The row to end calculating the column width. - IXLColumns AdjustToContents(Int32 startRow, Int32 endRow); + IXLColumns AdjustToContents(int startRow, int endRow); - IXLColumns AdjustToContents(Double minWidth, Double maxWidth); + IXLColumns AdjustToContents(double minWidth, double maxWidth); - IXLColumns AdjustToContents(Int32 startRow, Double minWidth, Double maxWidth); + IXLColumns AdjustToContents(int startRow, double minWidth, double maxWidth); - IXLColumns AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, Double maxWidth); + IXLColumns AdjustToContents(int startRow, int endRow, double minWidth, double maxWidth); /// /// Hides all columns. @@ -59,20 +58,20 @@ public interface IXLColumns : IEnumerable /// Increments the outline level of all columns by 1. /// /// If set to true the columns will be shown collapsed. - void Group(Boolean collapse); + void Group(bool collapse); /// /// Sets outline level for all columns. /// /// The outline level. - void Group(Int32 outlineLevel); + void Group(int outlineLevel); /// /// Sets outline level for all columns. /// /// The outline level. /// If set to true the columns will be shown collapsed. - void Group(Int32 outlineLevel, Boolean collapse); + void Group(int outlineLevel, bool collapse); /// /// Decrements the outline level of all columns by 1. @@ -83,7 +82,7 @@ public interface IXLColumns : IEnumerable /// Decrements the outline level of all columns by 1. /// /// If set to true it will remove the columns from all outline levels. - void Ungroup(Boolean fromAll); + void Ungroup(bool fromAll); /// /// Show all columns as collapsed. @@ -107,7 +106,7 @@ public interface IXLColumns : IEnumerable /// Returns the collection of cells that have a value. /// /// if set to true will return all cells with a value or a style different than the default. - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLStyle Style { get; set; } @@ -126,4 +125,4 @@ public interface IXLColumns : IEnumerable void Select(); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Columns/XLColumn.cs b/ClosedXML/Excel/Columns/XLColumn.cs index d6224b232..70f91ede6 100644 --- a/ClosedXML/Excel/Columns/XLColumn.cs +++ b/ClosedXML/Excel/Columns/XLColumn.cs @@ -1,6 +1,9 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Style; +using ClosedXML.Extensions; +using SkiaSharp; using System; using System.Collections.Generic; -using System.Drawing; using System.Linq; namespace ClosedXML.Excel @@ -16,9 +19,9 @@ internal class XLColumn : XLRangeBase, IXLColumn #region Constructor /// - /// The direct contructor should only be used in . + /// The direct constructor should only be used in . /// - public XLColumn(XLWorksheet worksheet, Int32 column) + public XLColumn(XLWorksheet worksheet, int column) : base(XLRangeAddress.EntireColumn(worksheet, column), worksheet.StyleValue) { SetColumnNumber(column); @@ -28,10 +31,7 @@ public XLColumn(XLWorksheet worksheet, Int32 column) #endregion Constructor - public override XLRangeType RangeType - { - get { return XLRangeType.Column; } - } + public override XLRangeType RangeType => XLRangeType.Column; public override IEnumerable Styles { @@ -39,10 +39,12 @@ public override IEnumerable Styles { yield return Style; - int column = ColumnNumber(); + var column = ColumnNumber(); - foreach (XLCell cell in Worksheet.Internals.CellsCollection.GetCellsInColumn(column)) + foreach (var cell in Worksheet.Internals.CellsCollection.GetCellsInColumn(column)) + { yield return cell.Style; + } } } @@ -50,21 +52,23 @@ protected override IEnumerable Children { get { - int column = ColumnNumber(); - foreach (XLCell cell in Worksheet.Internals.CellsCollection.GetCellsInColumn(column)) + var column = ColumnNumber(); + foreach (var cell in Worksheet.Internals.CellsCollection.GetCellsInColumn(column)) + { yield return cell; + } } } - public Boolean Collapsed { get; set; } + public bool Collapsed { get; set; } #region IXLColumn Members - public Double Width { get; set; } + public double Width { get; set; } public void Delete() { - int columnNumber = ColumnNumber(); + var columnNumber = ColumnNumber(); Delete(XLShiftDeletedCells.ShiftCellsLeft); Worksheet.DeleteColumn(columnNumber); } @@ -75,17 +79,20 @@ public void Delete() return this; } - public IXLCell Cell(Int32 rowNumber) + public IXLCell Cell(int rowNumber) { return Cell(rowNumber, 1); } - public override IXLCells Cells(String cellsInColumn) + public override IXLCells Cells(string cellsInColumn) { var retVal = new XLCells(false, XLCellsUsedOptions.All); var rangePairs = cellsInColumn.Split(','); - foreach (string pair in rangePairs) + foreach (var pair in rangePairs) + { retVal.Add(Range(pair.Trim()).RangeAddress); + } + return retVal; } @@ -94,22 +101,26 @@ public override IXLCells Cells() return Cells(true, XLCellsUsedOptions.All); } - public override IXLCells Cells(Boolean usedCellsOnly) + public override IXLCells Cells(bool usedCellsOnly) { if (usedCellsOnly) + { return Cells(true, XLCellsUsedOptions.AllContents); + } else + { return Cells(FirstCellUsed().Address.RowNumber, LastCellUsed().Address.RowNumber); + } } - public IXLCells Cells(Int32 firstRow, Int32 lastRow) + public IXLCells Cells(int firstRow, int lastRow) { return Cells(firstRow + ":" + lastRow); } - public new IXLColumns InsertColumnsAfter(Int32 numberOfColumns) + public new IXLColumns InsertColumnsAfter(int numberOfColumns) { - int columnNum = ColumnNumber(); + var columnNum = ColumnNumber(); Worksheet.Internals.ColumnsCollection.ShiftColumnsRight(columnNum + 1, numberOfColumns); Worksheet.Column(columnNum).InsertColumnsAfterVoid(true, numberOfColumns); var newColumns = Worksheet.Columns(columnNum + 1, columnNum + numberOfColumns); @@ -117,9 +128,9 @@ public IXLCells Cells(Int32 firstRow, Int32 lastRow) return newColumns; } - public new IXLColumns InsertColumnsBefore(Int32 numberOfColumns) + public new IXLColumns InsertColumnsBefore(int numberOfColumns) { - int columnNum = ColumnNumber(); + var columnNum = ColumnNumber(); if (columnNum > 1) { return Worksheet.Column(columnNum - 1).InsertColumnsAfter(numberOfColumns); @@ -149,35 +160,37 @@ public IXLColumn AdjustToContents() return AdjustToContents(1); } - public IXLColumn AdjustToContents(Int32 startRow) + public IXLColumn AdjustToContents(int startRow) { return AdjustToContents(startRow, XLHelper.MaxRowNumber); } - public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow) + public IXLColumn AdjustToContents(int startRow, int endRow) { - return AdjustToContents(startRow, endRow, 0, Double.MaxValue); + return AdjustToContents(startRow, endRow, 0, double.MaxValue); } - public IXLColumn AdjustToContents(Double minWidth, Double maxWidth) + public IXLColumn AdjustToContents(double minWidth, double maxWidth) { return AdjustToContents(1, XLHelper.MaxRowNumber, minWidth, maxWidth); } - public IXLColumn AdjustToContents(Int32 startRow, Double minWidth, Double maxWidth) + public IXLColumn AdjustToContents(int startRow, double minWidth, double maxWidth) { return AdjustToContents(startRow, XLHelper.MaxRowNumber, minWidth, maxWidth); } - public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, Double maxWidth) + public IXLColumn AdjustToContents(int startRow, int endRow, double minWidth, double maxWidth) { - var fontCache = new Dictionary(); + var fontCache = new Dictionary(); - Double colMaxWidth = minWidth; + var colMaxWidth = minWidth; - List autoFilterRows = new List(); - if (this.Worksheet.AutoFilter != null && this.Worksheet.AutoFilter.Range != null) - autoFilterRows.Add(this.Worksheet.AutoFilter.Range.FirstRow().RowNumber()); + var autoFilterRows = new List(); + if (Worksheet.AutoFilter != null && Worksheet.AutoFilter.Range != null) + { + autoFilterRows.Add(Worksheet.AutoFilter.Range.FirstRow().RowNumber()); + } autoFilterRows.AddRange(Worksheet.Tables.Where(t => t.AutoFilter != null @@ -188,13 +201,19 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, XLStyle cellStyle = null; foreach (var c in Column(startRow, endRow).CellsUsed().Cast()) { - if (c.IsMerged()) continue; + if (c.IsMerged()) + { + continue; + } + if (cellStyle == null || cellStyle.Value != c.StyleValue) + { cellStyle = c.Style as XLStyle; + } - Double thisWidthMax = 0; - Int32 textRotation = cellStyle.Alignment.TextRotation; - if (c.HasRichText || textRotation != 0 || c.InnerText.Contains(Environment.NewLine)) + double thisWidthMax = 0; + var textRotation = cellStyle.Alignment.TextRotation; + if (c.HasRichText || textRotation != 0 || c.InnerText.Contains(XLConstants.NewLine)) { var kpList = new List>(); @@ -202,31 +221,37 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, if (c.HasRichText) { - foreach (IXLRichString rt in c.GetRichText()) + foreach (var rt in c.GetRichText()) { - String formattedString = rt.Text; - var arr = formattedString.Split(new[] { Environment.NewLine }, StringSplitOptions.None); - Int32 arrCount = arr.Count(); - for (Int32 i = 0; i < arrCount; i++) + var formattedString = rt.Text; + var arr = formattedString.Split(new[] { XLConstants.NewLine }, StringSplitOptions.None); + var arrCount = arr.Length; + for (var i = 0; i < arrCount; i++) { - String s = arr[i]; + var s = arr[i]; if (i < arrCount - 1) - s += Environment.NewLine; - kpList.Add(new KeyValuePair(rt, s)); + { + s += XLConstants.NewLine; + } + + kpList.Add(new KeyValuePair(rt, s)); } } } else { - String formattedString = c.GetFormattedString(); - var arr = formattedString.Split(new[] { Environment.NewLine }, StringSplitOptions.None); - Int32 arrCount = arr.Count(); - for (Int32 i = 0; i < arrCount; i++) + var formattedString = c.GetFormattedString(); + var arr = formattedString.Split(new[] { XLConstants.NewLine }, StringSplitOptions.None); + var arrCount = arr.Length; + for (var i = 0; i < arrCount; i++) { - String s = arr[i]; + var s = arr[i]; if (i < arrCount - 1) - s += Environment.NewLine; - kpList.Add(new KeyValuePair(cellStyle.Font, s)); + { + s += XLConstants.NewLine; + } + + kpList.Add(new KeyValuePair(cellStyle.Font, s)); } } @@ -234,16 +259,16 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, #region foreach (var kp in kpList) - Double runningWidth = 0; - Boolean rotated = false; - Double maxLineWidth = 0; - Int32 lineCount = 1; - foreach (KeyValuePair kp in kpList) + double runningWidth = 0; + var rotated = false; + double maxLineWidth = 0; + var lineCount = 1; + foreach (var kp in kpList) { var f = kp.Key; - String formattedString = kp.Value; + var formattedString = kp.Value; - Int32 newLinePosition = formattedString.IndexOf(Environment.NewLine); + var newLinePosition = formattedString.IndexOf(XLConstants.NewLine); if (textRotation == 0) { #region if (newLinePosition >= 0) @@ -251,17 +276,23 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, if (newLinePosition >= 0) { if (newLinePosition > 0) + { runningWidth += f.GetWidth(formattedString.Substring(0, newLinePosition), fontCache); + } if (runningWidth > thisWidthMax) + { thisWidthMax = runningWidth; + } runningWidth = newLinePosition < formattedString.Length - 2 ? f.GetWidth(formattedString.Substring(newLinePosition + 2), fontCache) : 0; } else + { runningWidth += f.GetWidth(formattedString, fontCache); + } #endregion if (newLinePosition >= 0) } @@ -272,34 +303,46 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, if (textRotation == 255) { if (runningWidth <= 0) + { runningWidth = f.GetWidth("X", fontCache); + } if (newLinePosition >= 0) + { runningWidth += f.GetWidth("X", fontCache); + } } else { rotated = true; - Double vWidth = f.GetWidth("X", fontCache); + var vWidth = f.GetWidth("X", fontCache); if (vWidth > maxLineWidth) + { maxLineWidth = vWidth; + } if (newLinePosition >= 0) { lineCount++; if (newLinePosition > 0) + { runningWidth += f.GetWidth(formattedString.Substring(0, newLinePosition), fontCache); + } if (runningWidth > thisWidthMax) + { thisWidthMax = runningWidth; + } runningWidth = newLinePosition < formattedString.Length - 2 ? f.GetWidth(formattedString.Substring(newLinePosition + 2), fontCache) : 0; } else + { runningWidth += f.GetWidth(formattedString, fontCache); + } } #endregion if (textRotation == 255) @@ -309,19 +352,25 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, #endregion foreach (var kp in kpList) if (runningWidth > thisWidthMax) + { thisWidthMax = runningWidth; + } #region if (rotated) if (rotated) { - Int32 rotation; + int rotation; if (textRotation == 90 || textRotation == 180 || textRotation == 255) + { rotation = 90; + } else + { rotation = textRotation % 90; + } - Double r = DegreeToRadian(rotation); + var r = DegreeToRadian(rotation); thisWidthMax = (thisWidthMax * Math.Cos(r)) + (maxLineWidth * lineCount); } @@ -329,10 +378,15 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, #endregion if (rotated) } else + { thisWidthMax = cellStyle.Font.GetWidth(c.GetFormattedString(), fontCache); + } if (autoFilterRows.Contains(c.Address.RowNumber)) - thisWidthMax += 2.7148; // Allow room for arrow icon in autofilter + { + // Allow room for arrow icon in auto filter + thisWidthMax += 2.7148; + } if (thisWidthMax >= maxWidth) { @@ -341,11 +395,15 @@ public IXLColumn AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, } if (thisWidthMax > colMaxWidth) + { colMaxWidth = thisWidthMax + 1; + } } if (colMaxWidth <= 0) + { colMaxWidth = Worksheet.ColumnWidth; + } Width = colMaxWidth; @@ -368,15 +426,17 @@ public IXLColumn Unhide() return this; } - public Boolean IsHidden { get; set; } + public bool IsHidden { get; set; } - public Int32 OutlineLevel + public int OutlineLevel { get { return _outlineLevel; } set { if (value < 0 || value > 8) + { throw new ArgumentOutOfRangeException("value", "Outline level must be between 0 and 8."); + } Worksheet.IncrementColumnOutline(value); Worksheet.DecrementColumnOutline(_outlineLevel); @@ -389,21 +449,23 @@ public IXLColumn Group() return Group(false); } - public IXLColumn Group(Boolean collapse) + public IXLColumn Group(bool collapse) { if (OutlineLevel < 8) + { OutlineLevel += 1; + } Collapsed = collapse; return this; } - public IXLColumn Group(Int32 outlineLevel) + public IXLColumn Group(int outlineLevel) { return Group(outlineLevel, false); } - public IXLColumn Group(Int32 outlineLevel, Boolean collapse) + public IXLColumn Group(int outlineLevel, bool collapse) { OutlineLevel = outlineLevel; Collapsed = collapse; @@ -415,14 +477,18 @@ public IXLColumn Ungroup() return Ungroup(false); } - public IXLColumn Ungroup(Boolean ungroupFromAll) + public IXLColumn Ungroup(bool ungroupFromAll) { if (ungroupFromAll) + { OutlineLevel = 0; + } else { if (OutlineLevel > 0) + { OutlineLevel -= 1; + } } return this; } @@ -439,13 +505,13 @@ public IXLColumn Expand() return Unhide(); } - public Int32 CellCount() + public int CellCount() { return RangeAddress.LastAddress.ColumnNumber - RangeAddress.FirstAddress.ColumnNumber + 1; } - public IXLColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, - Boolean ignoreBlanks = true) + public IXLColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, + bool ignoreBlanks = true) { Sort(1, sortOrder, matchCase, ignoreBlanks); return this; @@ -476,7 +542,7 @@ public IXLColumn CopyTo(IXLColumn column) return newColumn; } - public IXLRangeColumn Column(Int32 start, Int32 end) + public IXLRangeColumn Column(int start, int end) { return Range(start, 1, end, 1).Column(1); } @@ -486,12 +552,15 @@ public IXLRangeColumn Column(IXLCell start, IXLCell end) return Column(start.Address.RowNumber, end.Address.RowNumber); } - public IXLRangeColumns Columns(String columns) + public IXLRangeColumns Columns(string columns) { var retVal = new XLRangeColumns(); var columnPairs = columns.Split(','); - foreach (string pair in columnPairs) + foreach (var pair in columnPairs) + { AsRange().Columns(pair.Trim()).ForEach(retVal.Add); + } + return retVal; } @@ -511,7 +580,7 @@ public IXLColumn SetDataType(XLDataType dataType) } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLRangeColumn ColumnUsed(Boolean includeFormats) + public IXLRangeColumn ColumnUsed(bool includeFormats) { return ColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -556,21 +625,25 @@ internal void SetColumnNumber(int column) RangeAddress.LastAddress.FixedColumn)); } - public override XLRange Range(String rangeAddressStr) + public override XLRange Range(string rangeAddressStr) { - String rangeAddressToUse; + string rangeAddressToUse; if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-')) { if (rangeAddressStr.Contains('-')) + { rangeAddressStr = rangeAddressStr.Replace('-', ':'); + } var arrRange = rangeAddressStr.Split(':'); - string firstPart = arrRange[0]; - string secondPart = arrRange[1]; + var firstPart = arrRange[0]; + var secondPart = arrRange[1]; rangeAddressToUse = FixColumnAddress(firstPart) + ":" + FixColumnAddress(secondPart); } else + { rangeAddressToUse = FixColumnAddress(rangeAddressStr); + } var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse); return Range(rangeAddress); @@ -586,7 +659,7 @@ private static double DegreeToRadian(double angle) return Math.PI * angle / 180.0; } - private XLColumn ColumnShift(Int32 columnsToShift) + private XLColumn ColumnShift(int columnsToShift) { return Worksheet.Column(ColumnNumber() + columnsToShift); } @@ -598,7 +671,7 @@ IXLColumn IXLColumn.ColumnLeft() return ColumnLeft(); } - IXLColumn IXLColumn.ColumnLeft(Int32 step) + IXLColumn IXLColumn.ColumnLeft(int step) { return ColumnLeft(step); } @@ -608,7 +681,7 @@ public XLColumn ColumnLeft() return ColumnLeft(1); } - public XLColumn ColumnLeft(Int32 step) + public XLColumn ColumnLeft(int step) { return ColumnShift(step * -1); } @@ -622,7 +695,7 @@ IXLColumn IXLColumn.ColumnRight() return ColumnRight(); } - IXLColumn IXLColumn.ColumnRight(Int32 step) + IXLColumn IXLColumn.ColumnRight(int step) { return ColumnRight(step); } @@ -632,35 +705,37 @@ public XLColumn ColumnRight() return ColumnRight(1); } - public XLColumn ColumnRight(Int32 step) + public XLColumn ColumnRight(int step) { return ColumnShift(step); } #endregion XLColumn Right - public override Boolean IsEmpty() + public override bool IsEmpty() { return IsEmpty(XLCellsUsedOptions.AllContents); } - public override Boolean IsEmpty(XLCellsUsedOptions options) + public override bool IsEmpty(XLCellsUsedOptions options) { if (options.HasFlag(XLCellsUsedOptions.NormalFormats) && !StyleValue.Equals(Worksheet.StyleValue)) + { return false; + } return base.IsEmpty(options); } - public override Boolean IsEntireRow() + public override bool IsEntireRow() { return false; } - public override Boolean IsEntireColumn() + public override bool IsEntireColumn() { return true; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Columns/XLColumnCollection.cs b/ClosedXML/Excel/Columns/XLColumnCollection.cs index 4c33ee9ee..e579fb3e0 100644 --- a/ClosedXML/Excel/Columns/XLColumnCollection.cs +++ b/ClosedXML/Excel/Columns/XLColumnCollection.cs @@ -4,15 +4,15 @@ namespace ClosedXML.Excel { - internal class XLColumnsCollection : IDictionary + internal class XLColumnsCollection : IDictionary { - public void ShiftColumnsRight(Int32 startingColumn, Int32 columnsToShift) + public void ShiftColumnsRight(int startingColumn, int columnsToShift) { foreach (var co in _dictionary.Keys.Where(k => k >= startingColumn).OrderByDescending(k => k)) { var columnToMove = _dictionary[co]; _dictionary.Remove(co); - Int32 newColumnNum = co + columnsToShift; + var newColumnNum = co + columnsToShift; if (newColumnNum <= XLHelper.MaxColumnNumber) { columnToMove.SetColumnNumber(newColumnNum); @@ -21,7 +21,7 @@ public void ShiftColumnsRight(Int32 startingColumn, Int32 columnsToShift) } } - private readonly Dictionary _dictionary = new Dictionary(); + private readonly Dictionary _dictionary = new Dictionary(); public void Add(int key, XLColumn value) { @@ -33,10 +33,7 @@ public bool ContainsKey(int key) return _dictionary.ContainsKey(key); } - public ICollection Keys - { - get { return _dictionary.Keys; } - } + public ICollection Keys => _dictionary.Keys; public bool Remove(int key) { @@ -48,10 +45,7 @@ public bool TryGetValue(int key, out XLColumn value) return _dictionary.TryGetValue(key, out value); } - public ICollection Values - { - get { return _dictionary.Values; } - } + public ICollection Values => _dictionary.Values; public XLColumn this[int key] { @@ -85,15 +79,9 @@ public void CopyTo(KeyValuePair[] array, int arrayIndex) throw new NotImplementedException(); } - public int Count - { - get { return _dictionary.Count; } - } + public int Count => _dictionary.Count; - public bool IsReadOnly - { - get { return false; } - } + public bool IsReadOnly => false; public bool Remove(KeyValuePair item) { @@ -110,9 +98,9 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() return _dictionary.GetEnumerator(); } - public void RemoveAll(Func predicate) + public void RemoveAll(Func predicate) { _dictionary.RemoveAll(predicate); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Columns/XLColumns.cs b/ClosedXML/Excel/Columns/XLColumns.cs index 8eda992cc..2c24adc32 100644 --- a/ClosedXML/Excel/Columns/XLColumns.cs +++ b/ClosedXML/Excel/Columns/XLColumns.cs @@ -1,11 +1,10 @@ -using System; +using ClosedXML.Excel.Style; +using System.Collections; using System.Collections.Generic; using System.Linq; namespace ClosedXML.Excel { - using System.Collections; - internal class XLColumns : XLStylizedBase, IXLColumns, IXLStylized { private readonly List _columnsCollection = new List(); @@ -41,13 +40,16 @@ IEnumerator IEnumerable.GetEnumerator() return GetEnumerator(); } - public Double Width + public double Width { set { Columns.ForEach(c => c.Width = value); - if (_worksheet == null) return; + if (_worksheet == null) + { + return; + } _worksheet.ColumnWidth = value; _worksheet.Internals.ColumnsCollection.ForEach(c => c.Value.Width = value); @@ -63,22 +65,24 @@ public void Delete() } else { - var toDelete = new Dictionary>(); - foreach (XLColumn c in Columns) + var toDelete = new Dictionary>(); + foreach (var c in Columns) { - if (!toDelete.TryGetValue(c.Worksheet, out List list)) + if (!toDelete.TryGetValue(c.Worksheet, out var list)) { - list = new List(); + list = new List(); toDelete.Add(c.Worksheet, list); } list.Add(c.ColumnNumber()); } - foreach (KeyValuePair> kp in toDelete) + foreach (var kp in toDelete) { - foreach (int c in kp.Value.OrderByDescending(c => c)) + foreach (var c in kp.Value.OrderByDescending(c => c)) + { kp.Key.Column(c).Delete(); + } } } } @@ -89,31 +93,31 @@ public IXLColumns AdjustToContents() return this; } - public IXLColumns AdjustToContents(Int32 startRow) + public IXLColumns AdjustToContents(int startRow) { Columns.ForEach(c => c.AdjustToContents(startRow)); return this; } - public IXLColumns AdjustToContents(Int32 startRow, Int32 endRow) + public IXLColumns AdjustToContents(int startRow, int endRow) { Columns.ForEach(c => c.AdjustToContents(startRow, endRow)); return this; } - public IXLColumns AdjustToContents(Double minWidth, Double maxWidth) + public IXLColumns AdjustToContents(double minWidth, double maxWidth) { Columns.ForEach(c => c.AdjustToContents(minWidth, maxWidth)); return this; } - public IXLColumns AdjustToContents(Int32 startRow, Double minWidth, Double maxWidth) + public IXLColumns AdjustToContents(int startRow, double minWidth, double maxWidth) { Columns.ForEach(c => c.AdjustToContents(startRow, minWidth, maxWidth)); return this; } - public IXLColumns AdjustToContents(Int32 startRow, Int32 endRow, Double minWidth, Double maxWidth) + public IXLColumns AdjustToContents(int startRow, int endRow, double minWidth, double maxWidth) { Columns.ForEach(c => c.AdjustToContents(startRow, endRow, minWidth, maxWidth)); return this; @@ -134,7 +138,7 @@ public void Group() Group(false); } - public void Group(Int32 outlineLevel) + public void Group(int outlineLevel) { Group(outlineLevel, false); } @@ -144,17 +148,17 @@ public void Ungroup() Ungroup(false); } - public void Group(Boolean collapse) + public void Group(bool collapse) { Columns.ForEach(c => c.Group(collapse)); } - public void Group(Int32 outlineLevel, Boolean collapse) + public void Group(int outlineLevel, bool collapse) { Columns.ForEach(c => c.Group(outlineLevel, collapse)); } - public void Ungroup(Boolean ungroupFromAll) + public void Ungroup(bool ungroupFromAll) { Columns.ForEach(c => c.Ungroup(ungroupFromAll)); } @@ -172,20 +176,26 @@ public void Expand() public IXLCells Cells() { var cells = new XLCells(false, XLCellsUsedOptions.All); - foreach (XLColumn container in Columns) + foreach (var container in Columns) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(true, XLCellsUsedOptions.All); - foreach (XLColumn container in Columns) + foreach (var container in Columns) + { cells.Add(container.RangeAddress); + } + return cells; } - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -193,10 +203,13 @@ public IXLCells CellsUsed(Boolean includeFormats) } public IXLCells CellsUsed(XLCellsUsedOptions options) - { + { var cells = new XLCells(true, options); - foreach (XLColumn container in Columns) + foreach (var container in Columns) + { cells.Add(container.RangeAddress); + } + return cells; } @@ -205,8 +218,11 @@ public IXLCells CellsUsed(XLCellsUsedOptions options) /// public IXLColumns AddVerticalPageBreaks() { - foreach (XLColumn col in Columns) + foreach (var col in Columns) + { col.Worksheet.PageSetup.AddVerticalPageBreak(col.ColumnNumber()); + } + return this; } @@ -226,10 +242,12 @@ public override IEnumerable Styles { yield return Style; if (_worksheet != null) + { yield return _worksheet.Style; + } else { - foreach (IXLStyle s in Columns.SelectMany(col => col.Styles)) + foreach (var s in Columns.SelectMany(col => col.Styles)) { yield return s; } @@ -242,11 +260,15 @@ protected override IEnumerable Children get { if (_worksheet != null) + { yield return _worksheet; + } else { - foreach (XLColumn column in Columns) + foreach (var column in Columns) + { yield return column; + } } } } @@ -283,16 +305,20 @@ public IXLColumns Clear(XLClearOptions clearOptions = XLClearOptions.All) public void Select() { foreach (var range in this) + { range.Select(); + } } private void Materialize() { if (IsMaterialized) + { return; + } _columnsCollection.AddRange(Columns); _lazyEnumerable = null; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Comments/IXLComment.cs b/ClosedXML/Excel/Comments/IXLComment.cs index 9b3b30e9a..7d11310b6 100644 --- a/ClosedXML/Excel/Comments/IXLComment.cs +++ b/ClosedXML/Excel/Comments/IXLComment.cs @@ -1,6 +1,3 @@ -using System; -using System.Collections.Generic; - namespace ClosedXML.Excel { public interface IXLComment : IXLFormattedText, IXLDrawing @@ -8,12 +5,12 @@ public interface IXLComment : IXLFormattedText, IXLDrawing /// Gets or sets this comment's author's name /// - String Author { get; set; } + string Author { get; set; } /// /// Sets the name of the comment's author /// /// Author's name - IXLComment SetAuthor(String value); + IXLComment SetAuthor(string value); /// /// Adds a bolded line with the author's name diff --git a/ClosedXML/Excel/Comments/XLComment.cs b/ClosedXML/Excel/Comments/XLComment.cs index 9144c40a6..dde12f977 100644 --- a/ClosedXML/Excel/Comments/XLComment.cs +++ b/ClosedXML/Excel/Comments/XLComment.cs @@ -1,3 +1,4 @@ +using ClosedXML.Excel.RichText; using System; namespace ClosedXML.Excel @@ -18,7 +19,7 @@ public XLComment(XLCell cell, XLFormattedText defaultComment, IXLFon Initialize(cell, style); } - public XLComment(XLCell cell, String text, IXLFontBase defaultFont) + public XLComment(XLCell cell, string text, IXLFontBase defaultFont) : base(text, defaultFont) { Initialize(cell); @@ -26,9 +27,9 @@ public XLComment(XLCell cell, String text, IXLFontBase defaultFont) #region IXLComment Members - public String Author { get; set; } + public string Author { get; set; } - public IXLComment SetAuthor(String value) + public IXLComment SetAuthor(string value) { Author = value; return this; @@ -37,7 +38,7 @@ public IXLComment SetAuthor(String value) public IXLRichString AddSignature() { AddText(Author + ":").SetBold(); - return AddText(Environment.NewLine); + return AddText(XLConstants.NewLine); } public void Delete() @@ -49,16 +50,16 @@ public void Delete() #region IXLDrawing - public String Name { get; set; } - public String Description { get; set; } + public string Name { get; set; } + public string Description { get; set; } public XLDrawingAnchor Anchor { get; set; } - public Boolean HorizontalFlip { get; set; } - public Boolean VerticalFlip { get; set; } - public Int32 Rotation { get; set; } - public Int32 ExtentLength { get; set; } - public Int32 ExtentWidth { get; set; } - public Int32 ShapeId { get; internal set; } - public Boolean Visible { get; set; } + public bool HorizontalFlip { get; set; } + public bool VerticalFlip { get; set; } + public int Rotation { get; set; } + public int ExtentLength { get; set; } + public int ExtentWidth { get; set; } + public int ShapeId { get; internal set; } + public bool Visible { get; set; } public IXLComment SetVisible() { @@ -66,7 +67,7 @@ public IXLComment SetVisible() return Container; } - public IXLComment SetVisible(Boolean hidden) + public IXLComment SetVisible(bool hidden) { Visible = hidden; return Container; @@ -74,9 +75,9 @@ public IXLComment SetVisible(Boolean hidden) public IXLDrawingPosition Position { get; private set; } - public Int32 ZOrder { get; set; } + public int ZOrder { get; set; } - public IXLComment SetZOrder(Int32 zOrder) + public IXLComment SetZOrder(int zOrder) { ZOrder = zOrder; return Container; @@ -84,13 +85,13 @@ public IXLComment SetZOrder(Int32 zOrder) public IXLDrawingStyle Style { get; private set; } - public IXLComment SetName(String name) + public IXLComment SetName(string name) { Name = name; return Container; } - public IXLComment SetDescription(String description) + public IXLComment SetDescription(string description) { Description = description; return Container; @@ -102,7 +103,7 @@ public IXLComment SetHorizontalFlip() return Container; } - public IXLComment SetHorizontalFlip(Boolean horizontalFlip) + public IXLComment SetHorizontalFlip(bool horizontalFlip) { HorizontalFlip = horizontalFlip; return Container; @@ -114,25 +115,25 @@ public IXLComment SetVerticalFlip() return Container; } - public IXLComment SetVerticalFlip(Boolean verticalFlip) + public IXLComment SetVerticalFlip(bool verticalFlip) { VerticalFlip = verticalFlip; return Container; } - public IXLComment SetRotation(Int32 rotation) + public IXLComment SetRotation(int rotation) { Rotation = rotation; return Container; } - public IXLComment SetExtentLength(Int32 extentLength) + public IXLComment SetExtentLength(int extentLength) { ExtentLength = extentLength; return Container; } - public IXLComment SetExtentWidth(Int32 extentWidth) + public IXLComment SetExtentWidth(int extentWidth) { ExtentWidth = extentWidth; return Container; @@ -149,17 +150,21 @@ private void Initialize(XLCell cell, IXLDrawingStyle style = null, int? shapeId Container = this; Anchor = XLDrawingAnchor.MoveAndSizeWithCells; Style = new XLDrawingStyle(); - Int32 previousRowNumber = cell.Address.RowNumber; - Double previousRowOffset = 0; + var previousRowNumber = cell.Address.RowNumber; + double previousRowOffset = 0; if (previousRowNumber > 1) { previousRowNumber--; - if (cell.Worksheet.Internals.RowsCollection.TryGetValue(previousRowNumber, out XLRow previousRow)) + if (cell.Worksheet.Internals.RowsCollection.TryGetValue(previousRowNumber, out var previousRow)) + { previousRowOffset = Math.Max(0, previousRow.Height - 7); + } else + { previousRowOffset = Math.Max(0, cell.Worksheet.RowHeight - 7); + } } Position = new XLDrawingPosition @@ -199,4 +204,4 @@ private void Initialize(XLCell cell, IXLDrawingStyle style = null, int? shapeId ShapeId = shapeId.Value; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs index 40217cd8e..c6e6a98a5 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMax.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLCFColorScaleMax { - void Maximum(XLCFContentType type, String value, XLColor color); - void Maximum(XLCFContentType type, Double value, XLColor color); + void Maximum(XLCFContentType type, string value, XLColor color); + void Maximum(XLCFContentType type, double value, XLColor color); void HighestValue(XLColor color); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs index 95e514538..431e51999 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMid.cs @@ -1,16 +1,11 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLCFColorScaleMid { - IXLCFColorScaleMax Midpoint(XLCFContentType type, String value, XLColor color); - IXLCFColorScaleMax Midpoint(XLCFContentType type, Double value, XLColor color); - void Maximum(XLCFContentType type, String value, XLColor color); - void Maximum(XLCFContentType type, Double value, XLColor color); + IXLCFColorScaleMax Midpoint(XLCFContentType type, string value, XLColor color); + IXLCFColorScaleMax Midpoint(XLCFContentType type, double value, XLColor color); + void Maximum(XLCFContentType type, string value, XLColor color); + void Maximum(XLCFContentType type, double value, XLColor color); void HighestValue(XLColor color); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs index 7abc9ea3b..5219d7c1b 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFColorScaleMin.cs @@ -1,15 +1,10 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public enum XLCFContentType { Number, Percent, Formula, Percentile, Minimum, Maximum } public interface IXLCFColorScaleMin { - IXLCFColorScaleMid Minimum(XLCFContentType type, String value, XLColor color); - IXLCFColorScaleMid Minimum(XLCFContentType type, Double value, XLColor color); + IXLCFColorScaleMid Minimum(XLCFContentType type, string value, XLColor color); + IXLCFColorScaleMid Minimum(XLCFContentType type, double value, XLColor color); IXLCFColorScaleMid LowestValue(XLColor color); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs index 05df66a4c..180ec5355 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMax.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLCFDataBarMax { - void Maximum(XLCFContentType type, String value); - void Maximum(XLCFContentType type, Double value); + void Maximum(XLCFContentType type, string value); + void Maximum(XLCFContentType type, double value); void HighestValue(); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs index cd1236fc7..8a75cf2dd 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFDataBarMin.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLCFDataBarMin { - IXLCFDataBarMax Minimum(XLCFContentType type, String value); - IXLCFDataBarMax Minimum(XLCFContentType type, Double value); + IXLCFDataBarMax Minimum(XLCFContentType type, string value); + IXLCFDataBarMax Minimum(XLCFContentType type, double value); IXLCFDataBarMax LowestValue(); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs b/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs index e9f80737c..0fa866b52 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLCFIconSet.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public enum XLCFIconSetOperator {GreaterThan, EqualOrGreaterThan} public interface IXLCFIconSet { - IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, String value, XLCFContentType type); - IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, Double value, XLCFContentType type); + IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, string value, XLCFContentType type); + IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, double value, XLCFContentType type); } } diff --git a/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs b/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs index ba18bf4fe..e4f1bbe8f 100644 --- a/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs +++ b/ClosedXML/Excel/ConditionalFormats/IXLConditionalFormat.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLTimePeriod @@ -75,63 +73,63 @@ public interface IXLConditionalFormat IXLStyle WhenDateIs(XLTimePeriod timePeriod); - IXLStyle WhenContains(String value); + IXLStyle WhenContains(string value); - IXLStyle WhenNotContains(String value); + IXLStyle WhenNotContains(string value); - IXLStyle WhenStartsWith(String value); + IXLStyle WhenStartsWith(string value); - IXLStyle WhenEndsWith(String value); + IXLStyle WhenEndsWith(string value); - IXLStyle WhenEquals(String value); + IXLStyle WhenEquals(string value); - IXLStyle WhenNotEquals(String value); + IXLStyle WhenNotEquals(string value); - IXLStyle WhenGreaterThan(String value); + IXLStyle WhenGreaterThan(string value); - IXLStyle WhenLessThan(String value); + IXLStyle WhenLessThan(string value); - IXLStyle WhenEqualOrGreaterThan(String value); + IXLStyle WhenEqualOrGreaterThan(string value); - IXLStyle WhenEqualOrLessThan(String value); + IXLStyle WhenEqualOrLessThan(string value); - IXLStyle WhenBetween(String minValue, String maxValue); + IXLStyle WhenBetween(string minValue, string maxValue); - IXLStyle WhenNotBetween(String minValue, String maxValue); + IXLStyle WhenNotBetween(string minValue, string maxValue); - IXLStyle WhenEquals(Double value); + IXLStyle WhenEquals(double value); - IXLStyle WhenNotEquals(Double value); + IXLStyle WhenNotEquals(double value); - IXLStyle WhenGreaterThan(Double value); + IXLStyle WhenGreaterThan(double value); - IXLStyle WhenLessThan(Double value); + IXLStyle WhenLessThan(double value); - IXLStyle WhenEqualOrGreaterThan(Double value); + IXLStyle WhenEqualOrGreaterThan(double value); - IXLStyle WhenEqualOrLessThan(Double value); + IXLStyle WhenEqualOrLessThan(double value); - IXLStyle WhenBetween(Double minValue, Double maxValue); + IXLStyle WhenBetween(double minValue, double maxValue); - IXLStyle WhenNotBetween(Double minValue, Double maxValue); + IXLStyle WhenNotBetween(double minValue, double maxValue); IXLStyle WhenIsDuplicate(); IXLStyle WhenIsUnique(); - IXLStyle WhenIsTrue(String formula); + IXLStyle WhenIsTrue(string formula); - IXLStyle WhenIsTop(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items); + IXLStyle WhenIsTop(int value, XLTopBottomType topBottomType = XLTopBottomType.Items); - IXLStyle WhenIsBottom(Int32 value, XLTopBottomType topBottomType); + IXLStyle WhenIsBottom(int value, XLTopBottomType topBottomType); IXLCFColorScaleMin ColorScale(); - IXLCFDataBarMin DataBar(XLColor color, Boolean showBarOnly = false); + IXLCFDataBarMin DataBar(XLColor color, bool showBarOnly = false); - IXLCFDataBarMin DataBar(XLColor positiveColor, XLColor negativeColor, Boolean showBarOnly = false); + IXLCFDataBarMin DataBar(XLColor positiveColor, XLColor negativeColor, bool showBarOnly = false); - IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, Boolean reverseIconOrder = false, Boolean showIconOnly = false); + IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, bool reverseIconOrder = false, bool showIconOnly = false); XLConditionalFormatType ConditionalFormatType { get; } @@ -139,13 +137,13 @@ public interface IXLConditionalFormat XLTimePeriod TimePeriod { get; } - Boolean ReverseIconOrder { get; } + bool ReverseIconOrder { get; } - Boolean ShowIconOnly { get; } + bool ShowIconOnly { get; } - Boolean ShowBarOnly { get; } + bool ShowBarOnly { get; } - Boolean StopIfTrue { get; } + bool StopIfTrue { get; } /// /// The first of the . @@ -164,13 +162,13 @@ public interface IXLConditionalFormat XLCFOperator Operator { get; } - Boolean Bottom { get; } + bool Bottom { get; } - Boolean Percent { get; } + bool Percent { get; } IXLConditionalFormat SetStopIfTrue(); - IXLConditionalFormat SetStopIfTrue(Boolean value); + IXLConditionalFormat SetStopIfTrue(bool value); IXLConditionalFormat CopyTo(IXLWorksheet targetSheet); } diff --git a/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs index bfa177858..d44ff0c0f 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverter.cs @@ -1,13 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; using DocumentFormat.OpenXml.Spreadsheet; namespace ClosedXML.Excel { internal interface IXLCFConverter { - ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context); + ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context); } } diff --git a/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverterExtension.cs b/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverterExtension.cs index 82b11a0f3..cb8d99a00 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverterExtension.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/IXLCFConverterExtension.cs @@ -1,8 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using DocumentFormat.OpenXml.Office2010.Excel; +using DocumentFormat.OpenXml.Office2010.Excel; namespace ClosedXML.Excel { diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFCellIsConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFCellIsConverter.cs index 256eaef10..a66e99cbd 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFCellIsConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFCellIsConverter.cs @@ -1,6 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; -using System.Globalization; namespace ClosedXML.Excel { @@ -8,12 +6,14 @@ internal class XLCFCellIsConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - String val = GetQuoted(cf.Values[1]); + var val = GetQuoted(cf.Values[1]); var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Operator = cf.Operator.ToOpenXml(); @@ -29,18 +29,18 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, return conditionalFormattingRule; } - private String GetQuoted(XLFormula formula) + private string GetQuoted(XLFormula formula) { - String value = formula.Value; + var value = formula.Value; if (formula.IsFormula || value.StartsWith("\"") && value.EndsWith("\"") || - Double.TryParse(value, XLHelper.NumberStyle, XLHelper.ParseCulture, out double num)) + double.TryParse(value, XLHelper.NumberStyle, XLHelper.ParseCulture, out var num)) { return value; } - return String.Format("\"{0}\"", value.Replace("\"", "\"\"")); + return string.Format("\"{0}\"", value.Replace("\"", "\"\"")); } } } diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs index b47906e69..87d3076de 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFColorScaleConverter.cs @@ -1,28 +1,29 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { internal class XLCFColorScaleConverter : IXLCFConverter { - public ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context) + public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var colorScale = new ColorScale(); - for (Int32 i = 1; i <= cf.ContentTypes.Count; i++) + for (var i = 1; i <= cf.ContentTypes.Count; i++) { var type = cf.ContentTypes[i].ToOpenXml(); - var val = cf.Values.TryGetValue(i, out XLFormula formula) ? formula?.Value : null; + var val = cf.Values.TryGetValue(i, out var formula) ? formula?.Value : null; var conditionalFormatValueObject = new ConditionalFormatValueObject { Type = type }; if (val != null) + { conditionalFormatValueObject.Val = val; + } colorScale.Append(conditionalFormatValueObject); } - for (Int32 i = 1; i <= cf.Colors.Count; i++) + for (var i = 1; i <= cf.Colors.Count; i++) { var xlColor = cf.Colors[i]; var color = new Color(); diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFContainsConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFContainsConverter.cs index d4a43af62..00e3d41ae 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFContainsConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFContainsConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -7,11 +6,13 @@ internal class XLCFContainsConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - String val = cf.Values[1].Value; + var val = cf.Values[1].Value; var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Operator = ConditionalFormattingOperatorValues.ContainsText; conditionalFormattingRule.Text = val; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs index c451c7c3f..c70019999 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFConverters.cs @@ -31,10 +31,12 @@ static XLCFConverters() }; } - public static ConditionalFormattingRule Convert(IXLConditionalFormat conditionalFormat, Int32 priority, XLWorkbook.SaveContext context) + public static ConditionalFormattingRule Convert(IXLConditionalFormat conditionalFormat, int priority, XLWorkbook.SaveContext context) { if (!Converters.TryGetValue(conditionalFormat.ConditionalFormatType, out var converter)) + { throw new NotImplementedException(string.Format("Conditional formatting rule '{0}' hasn't been implemented", conditionalFormat.ConditionalFormatType)); + } return converter.Convert(conditionalFormat, priority, context); } diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFConvertersExtension.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFConvertersExtension.cs index 7b859511f..845edd76f 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFConvertersExtension.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFConvertersExtension.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Office2010.Excel; -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -10,7 +9,7 @@ internal class XLCFConvertersExtension static XLCFConvertersExtension() { - XLCFConvertersExtension.Converters = new Dictionary() + Converters = new Dictionary() { { XLConditionalFormatType.DataBar, new XLCFDataBarConverterExtension() } }; @@ -22,7 +21,7 @@ public XLCFConvertersExtension() public static ConditionalFormattingRule Convert(IXLConditionalFormat conditionalFormat, XLWorkbook.SaveContext context) { - return XLCFConvertersExtension.Converters[conditionalFormat.ConditionalFormatType].Convert(conditionalFormat, context); + return Converters[conditionalFormat.ConditionalFormatType].Convert(conditionalFormat, context); } } } \ No newline at end of file diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverter.cs index 91919a961..c6c19d0fa 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverter.cs @@ -1,13 +1,11 @@ using ClosedXML.Extensions; -using DocumentFormat.OpenXml; using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { internal class XLCFDataBarConverter : IXLCFConverter { - public ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context) + public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverterExtension.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverterExtension.cs index 8c24428f4..6494e2a20 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverterExtension.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDataBarConverterExtension.cs @@ -14,13 +14,13 @@ public XLCFDataBarConverterExtension() public ConditionalFormattingRule Convert(IXLConditionalFormat cf, XLWorkbook.SaveContext context) { - ConditionalFormattingRule conditionalFormattingRule = new ConditionalFormattingRule() + var conditionalFormattingRule = new ConditionalFormattingRule() { Type = DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValues.DataBar, Id = (cf as XLConditionalFormat).Id.WrapInBraces() }; - DataBar dataBar = new DataBar() + var dataBar = new DataBar() { MinLength = 0, MaxLength = 100, @@ -73,16 +73,22 @@ private ConditionalFormattingValueObjectTypeValues Convert(DocumentFormat.OpenXm { case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Max: return ConditionalFormattingValueObjectTypeValues.AutoMax; + case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Min: return ConditionalFormattingValueObjectTypeValues.AutoMin; + case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Number: return ConditionalFormattingValueObjectTypeValues.Numeric; + case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Percent: return ConditionalFormattingValueObjectTypeValues.Percent; + case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Percentile: return ConditionalFormattingValueObjectTypeValues.Percentile; + case DocumentFormat.OpenXml.Spreadsheet.ConditionalFormatValueObjectValues.Formula: return ConditionalFormattingValueObjectTypeValues.Formula; + default: throw new NotImplementedException(); } diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDatesOccuringConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDatesOccuringConverter.cs index e71d3c400..d218fc5cd 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFDatesOccuringConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFDatesOccuringConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -25,12 +24,14 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.TimePeriod = cf.TimePeriod.ToOpenXml(); var address = cf.Range.RangeAddress.FirstAddress.ToStringRelative(false); - var formula = new Formula { Text = String.Format(formulaTemplates[cf.TimePeriod], address) }; + var formula = new Formula { Text = string.Format(formulaTemplates[cf.TimePeriod], address) }; conditionalFormattingRule.Append(formula); diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFEndsWithConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFEndsWithConverter.cs index df10a3164..7a3e45a90 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFEndsWithConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFEndsWithConverter.cs @@ -1,4 +1,3 @@ -using System; using DocumentFormat.OpenXml.Spreadsheet; namespace ClosedXML.Excel @@ -7,11 +6,13 @@ internal class XLCFEndsWithConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - String val = cf.Values[1].Value; + var val = cf.Values[1].Value; var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Operator = ConditionalFormattingOperatorValues.EndsWith; conditionalFormattingRule.Text = val; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIconSetConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIconSetConverter.cs index 722465d31..dd2178dec 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIconSetConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIconSetConverter.cs @@ -1,17 +1,16 @@ -using System; using DocumentFormat.OpenXml.Spreadsheet; namespace ClosedXML.Excel { internal class XLCFIconSetConverter:IXLCFConverter { - public ConditionalFormattingRule Convert(IXLConditionalFormat cf, Int32 priority, XLWorkbook.SaveContext context) + public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var iconSet = new IconSet {ShowValue = !cf.ShowIconOnly, Reverse = cf.ReverseIconOrder, IconSetValue = cf.IconSetStyle.ToOpenXml()}; - Int32 count = cf.Values.Count; - for(Int32 i=1;i<= count; i++ ) + var count = cf.Values.Count; + for(var i =1;i<= count; i++ ) { var conditionalFormatValueObject = new ConditionalFormatValueObject { Type = cf.ContentTypes[i].ToOpenXml(), Val = cf.Values[i].Value, GreaterThanOrEqual = cf.IconSetOperators[i] == XLCFIconSetOperator.EqualOrGreaterThan}; iconSet.Append(conditionalFormatValueObject); diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsBlankConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsBlankConverter.cs index 8571b7f94..c88ef8c15 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsBlankConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsBlankConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -10,7 +9,9 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } var formula = new Formula { Text = "LEN(TRIM(" + cf.Range.RangeAddress.FirstAddress.ToStringRelative(false) + "))=0" }; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsErrorConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsErrorConverter.cs index b98be0520..417298a6b 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsErrorConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFIsErrorConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -10,7 +9,9 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } var formula = new Formula { Text = "ISERROR(" + cf.Range.RangeAddress.FirstAddress.ToStringRelative(false) + ")" }; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotBlankConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotBlankConverter.cs index d6b60416c..5ac1847f7 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotBlankConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotBlankConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -10,7 +9,9 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } var formula = new Formula { Text = "LEN(TRIM(" + cf.Range.RangeAddress.FirstAddress.ToStringRelative(false) + "))>0" }; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotContainsConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotContainsConverter.cs index 94d310a05..6d0565e9f 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotContainsConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotContainsConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -7,11 +6,13 @@ internal class XLCFNotContainsConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - String val = cf.Values[1].Value; + var val = cf.Values[1].Value; var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Operator = ConditionalFormattingOperatorValues.NotContains; conditionalFormattingRule.Text = val; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotErrorConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotErrorConverter.cs index e09299d78..19d295871 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotErrorConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFNotErrorConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -10,7 +9,9 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } var formula = new Formula { Text = "NOT(ISERROR(" + cf.Range.RangeAddress.FirstAddress.ToStringRelative(false) + "))" }; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFStartsWithConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFStartsWithConverter.cs index 1b5d124e4..5019b0c09 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFStartsWithConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFStartsWithConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -7,11 +6,13 @@ internal class XLCFStartsWithConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - String val = cf.Values[1].Value; + var val = cf.Values[1].Value; var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Operator = ConditionalFormattingOperatorValues.BeginsWith; conditionalFormattingRule.Text = val; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFTopConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFTopConverter.cs index 4870315a5..12ea31b96 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFTopConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFTopConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -7,11 +6,13 @@ internal class XLCFTopConverter : IXLCFConverter { public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, XLWorkbook.SaveContext context) { - UInt32 val = UInt32.Parse(cf.Values[1].Value); + var val = uint.Parse(cf.Values[1].Value); var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } conditionalFormattingRule.Percent = cf.Percent; conditionalFormattingRule.Rank = val; diff --git a/ClosedXML/Excel/ConditionalFormats/Save/XLCFUniqueConverter.cs b/ClosedXML/Excel/ConditionalFormats/Save/XLCFUniqueConverter.cs index fddc065b0..188c30a8a 100644 --- a/ClosedXML/Excel/ConditionalFormats/Save/XLCFUniqueConverter.cs +++ b/ClosedXML/Excel/ConditionalFormats/Save/XLCFUniqueConverter.cs @@ -1,5 +1,4 @@ using DocumentFormat.OpenXml.Spreadsheet; -using System; namespace ClosedXML.Excel { @@ -10,7 +9,9 @@ public ConditionalFormattingRule Convert(IXLConditionalFormat cf, int priority, var conditionalFormattingRule = XLCFBaseConverter.Convert(cf, priority); var cfStyle = (cf.Style as XLStyle).Value; if (!cfStyle.Equals(XLWorkbook.DefaultStyleValue)) - conditionalFormattingRule.FormatId = (UInt32)context.DifferentialFormats[cfStyle]; + { + conditionalFormattingRule.FormatId = (uint)context.DifferentialFormats[cfStyle]; + } return conditionalFormattingRule; } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs index 8d4cd00a3..657937633 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMax.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLCFColorScaleMax : IXLCFColorScaleMax @@ -10,13 +8,13 @@ public XLCFColorScaleMax(XLConditionalFormat conditionalFormat) _conditionalFormat = conditionalFormat; } - public void Maximum(XLCFContentType type, String value, XLColor color) + public void Maximum(XLCFContentType type, string value, XLColor color) { _conditionalFormat.Values.Add(new XLFormula { Value = value }); _conditionalFormat.Colors.Add(color); _conditionalFormat.ContentTypes.Add(type); } - public void Maximum(XLCFContentType type, Double value, XLColor color) + public void Maximum(XLCFContentType type, double value, XLColor color) { Maximum(type, value.ToInvariantString(), color); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs index 222649eec..db7ad3acc 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMid.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLCFColorScaleMid : IXLCFColorScaleMid @@ -9,22 +7,22 @@ public XLCFColorScaleMid(XLConditionalFormat conditionalFormat) { _conditionalFormat = conditionalFormat; } - public IXLCFColorScaleMax Midpoint(XLCFContentType type, String value, XLColor color) + public IXLCFColorScaleMax Midpoint(XLCFContentType type, string value, XLColor color) { _conditionalFormat.Values.Add(new XLFormula { Value = value }); _conditionalFormat.Colors.Add(color); _conditionalFormat.ContentTypes.Add(type); return new XLCFColorScaleMax(_conditionalFormat); } - public IXLCFColorScaleMax Midpoint(XLCFContentType type, Double value, XLColor color) + public IXLCFColorScaleMax Midpoint(XLCFContentType type, double value, XLColor color) { return Midpoint(type, value.ToInvariantString(), color); } - public void Maximum(XLCFContentType type, String value, XLColor color) + public void Maximum(XLCFContentType type, string value, XLColor color) { Midpoint(type, value, color); } - public void Maximum(XLCFContentType type, Double value, XLColor color) + public void Maximum(XLCFContentType type, double value, XLColor color) { Maximum(type, value.ToInvariantString(), color); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs index 35c9a78db..f2613697b 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFColorScaleMin.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLCFColorScaleMin : IXLCFColorScaleMin @@ -13,14 +8,14 @@ public XLCFColorScaleMin(XLConditionalFormat conditionalFormat) _conditionalFormat = conditionalFormat; } - public IXLCFColorScaleMid Minimum(XLCFContentType type, String value, XLColor color) + public IXLCFColorScaleMid Minimum(XLCFContentType type, string value, XLColor color) { _conditionalFormat.Values.Initialize(new XLFormula { Value = value }); _conditionalFormat.Colors.Initialize(color); _conditionalFormat.ContentTypes.Initialize(type); return new XLCFColorScaleMid(_conditionalFormat); } - public IXLCFColorScaleMid Minimum(XLCFContentType type, Double value, XLColor color) + public IXLCFColorScaleMid Minimum(XLCFContentType type, double value, XLColor color) { return Minimum(type, value.ToInvariantString(), color); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs b/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs index 50658acfd..683d2bf4a 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMax.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLCFDataBarMax : IXLCFDataBarMax @@ -13,12 +8,12 @@ public XLCFDataBarMax(XLConditionalFormat conditionalFormat) _conditionalFormat = conditionalFormat; } - public void Maximum(XLCFContentType type, String value) + public void Maximum(XLCFContentType type, string value) { _conditionalFormat.ContentTypes.Add(type); _conditionalFormat.Values.Add(new XLFormula { Value = value }); } - public void Maximum(XLCFContentType type, Double value) + public void Maximum(XLCFContentType type, double value) { Maximum(type, value.ToInvariantString()); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs b/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs index b6803dc91..3e6d4ced5 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFDataBarMin.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLCFDataBarMin : IXLCFDataBarMin @@ -13,13 +8,13 @@ public XLCFDataBarMin(XLConditionalFormat conditionalFormat) _conditionalFormat = conditionalFormat; } - public IXLCFDataBarMax Minimum(XLCFContentType type, String value) + public IXLCFDataBarMax Minimum(XLCFContentType type, string value) { _conditionalFormat.ContentTypes.Initialize(type); _conditionalFormat.Values.Initialize(new XLFormula { Value = value }); return new XLCFDataBarMax(_conditionalFormat); } - public IXLCFDataBarMax Minimum(XLCFContentType type, Double value) + public IXLCFDataBarMax Minimum(XLCFContentType type, double value) { return Minimum(type, value.ToInvariantString()); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs b/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs index 2c88ea59b..c8db2e8e6 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLCFIconSet.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLCFIconSet : IXLCFIconSet @@ -9,14 +7,14 @@ public XLCFIconSet(XLConditionalFormat conditionalFormat) { _conditionalFormat = conditionalFormat; } - public IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, String value, XLCFContentType type) + public IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, string value, XLCFContentType type) { _conditionalFormat.IconSetOperators.Add(setOperator); _conditionalFormat.Values.Add(new XLFormula { Value = value }); _conditionalFormat.ContentTypes.Add(type); return new XLCFIconSet(_conditionalFormat); } - public IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, Double value, XLCFContentType type) + public IXLCFIconSet AddValue(XLCFIconSetOperator setOperator, double value, XLCFContentType type) { return AddValue(setOperator, value.ToInvariantString(), type); } diff --git a/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs b/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs index 7012825e4..4461d45e4 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLConditionalFormat.cs @@ -1,3 +1,5 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Style; using System; using System.Collections.Generic; using System.Linq; @@ -23,10 +25,25 @@ public bool Equals(IXLConditionalFormat x, IXLConditionalFormat y) { var xx = (XLConditionalFormat)x; var yy = (XLConditionalFormat)y; - if (ReferenceEquals(xx, yy)) return true; - if (ReferenceEquals(xx, null)) return false; - if (ReferenceEquals(yy, null)) return false; - if (xx.GetType() != yy.GetType()) return false; + if (ReferenceEquals(xx, yy)) + { + return true; + } + + if (xx is null) + { + return false; + } + + if (yy is null) + { + return false; + } + + if (xx.GetType() != yy.GetType()) + { + return false; + } var xxValues = xx.Values.Values.Where(v => v == null || !v.IsFormula).Select(v => v?.Value); var yyValues = yy.Values.Values.Where(v => v == null || !v.IsFormula).Select(v => v?.Value); @@ -53,7 +70,7 @@ public bool Equals(IXLConditionalFormat x, IXLConditionalFormat y) && _colorsComparer.Equals(xx.Colors, yy.Colors) && _contentsTypeComparer.Equals(xx.ContentTypes, yy.ContentTypes) && _iconSetTypeComparer.Equals(xx.IconSetOperators, yy.IconSetOperators) - && (!_compareRange || XLRanges.Equals(xx.Ranges, yy.Ranges)); + && (!_compareRange || Equals(xx.Ranges, yy.Ranges)); } public int GetHashCode(IXLConditionalFormat obj) @@ -62,8 +79,10 @@ public int GetHashCode(IXLConditionalFormat obj) var xStyle = (obj.Style as XLStyle).Value; var xValues = xx.Values.Values.Where(v => !v.IsFormula).Select(v => v.Value); if (obj.Ranges.Count > 0) + { xValues = xValues .Union(xx.Values.Values.Where(v => v.IsFormula).Select(f => ((XLCell)obj.Ranges.First().FirstCell()).GetFormulaR1C1(f.Value))); + } unchecked { @@ -96,7 +115,9 @@ internal void AdjustFormulas(XLCell baseCell, XLCell targetCell) foreach (var key in keys) { if (Values[key] == null || !Values[key].IsFormula) + { continue; + } var r1c1 = baseCell.GetFormulaR1C1(Values[key].Value); Values[key] = new XLFormula { _value = targetCell.GetFormulaA1(r1c1), IsFormula = true }; @@ -105,17 +126,11 @@ internal void AdjustFormulas(XLCell baseCell, XLCell targetCell) private static readonly IEqualityComparer FullComparerInstance = new FullEqualityComparer(true); - public static IEqualityComparer FullComparer - { - get { return FullComparerInstance; } - } + public static IEqualityComparer FullComparer => FullComparerInstance; private static readonly IEqualityComparer NoRangeComparerInstance = new FullEqualityComparer(false); - public static IEqualityComparer NoRangeComparer - { - get { return NoRangeComparerInstance; } - } + public static IEqualityComparer NoRangeComparer => NoRangeComparerInstance; #region Constructors @@ -130,15 +145,18 @@ private XLConditionalFormat(XLStyleValue style) IconSetOperators = new XLDictionary(); } - public XLConditionalFormat(XLRange range, Boolean copyDefaultModify = false) + public XLConditionalFormat(XLRange range, bool copyDefaultModify = false) : this(XLStyle.Default.Value) { if (range != null) + { Ranges.Add(range); + } + CopyDefaultModify = copyDefaultModify; } - public XLConditionalFormat(IEnumerable ranges, Boolean copyDefaultModify = false) + public XLConditionalFormat(IEnumerable ranges, bool copyDefaultModify = false) : this(XLStyle.Default.Value) { ranges?.ForEach(range => Ranges.Add(range)); @@ -161,9 +179,9 @@ public XLConditionalFormat(XLConditionalFormat conditionalFormat, IEnumerable Styles { @@ -178,10 +196,7 @@ protected override IEnumerable Children get { yield break; } } - public override IXLRanges RangesUsed - { - get { return new XLRanges(); } - } + public override IXLRanges RangesUsed => new XLRanges(); public XLDictionary Values { get; private set; } @@ -211,17 +226,17 @@ public IXLRange Range public XLCFOperator Operator { get; set; } - public Boolean Bottom { get; set; } + public bool Bottom { get; set; } - public Boolean Percent { get; set; } + public bool Percent { get; set; } - public Boolean ReverseIconOrder { get; set; } + public bool ReverseIconOrder { get; set; } - public Boolean ShowIconOnly { get; set; } + public bool ShowIconOnly { get; set; } - public Boolean ShowBarOnly { get; set; } + public bool ShowBarOnly { get; set; } - public Boolean StopIfTrue { get; set; } + public bool StopIfTrue { get; set; } public IXLConditionalFormat SetStopIfTrue() { @@ -230,14 +245,17 @@ public IXLConditionalFormat SetStopIfTrue() public IXLConditionalFormat SetStopIfTrue(bool value) { - this.StopIfTrue = value; + StopIfTrue = value; return this; } public IXLConditionalFormat CopyTo(IXLWorksheet targetSheet) { if (targetSheet == Range?.Worksheet) + { throw new InvalidOperationException("Cannot copy conditional format to the worksheet it already belongs to."); + } + var targetRanges = Ranges.Select(r => targetSheet.Range(((XLRangeAddress)r.RangeAddress).WithoutWorksheet())); var newCf = new XLConditionalFormat(this, targetRanges); targetSheet.ConditionalFormats.Add(newCf); @@ -303,7 +321,7 @@ public IXLStyle WhenDateIs(XLTimePeriod timePeriod) return Style; } - public IXLStyle WhenContains(String value) + public IXLStyle WhenContains(string value) { Values.Initialize(new XLFormula { Value = value }); ConditionalFormatType = XLConditionalFormatType.ContainsText; @@ -311,7 +329,7 @@ public IXLStyle WhenContains(String value) return Style; } - public IXLStyle WhenNotContains(String value) + public IXLStyle WhenNotContains(string value) { Values.Initialize(new XLFormula { Value = value }); ConditionalFormatType = XLConditionalFormatType.NotContainsText; @@ -319,7 +337,7 @@ public IXLStyle WhenNotContains(String value) return Style; } - public IXLStyle WhenStartsWith(String value) + public IXLStyle WhenStartsWith(string value) { Values.Initialize(new XLFormula { Value = value }); ConditionalFormatType = XLConditionalFormatType.StartsWith; @@ -327,7 +345,7 @@ public IXLStyle WhenStartsWith(String value) return Style; } - public IXLStyle WhenEndsWith(String value) + public IXLStyle WhenEndsWith(string value) { Values.Initialize(new XLFormula { Value = value }); ConditionalFormatType = XLConditionalFormatType.EndsWith; @@ -335,7 +353,7 @@ public IXLStyle WhenEndsWith(String value) return Style; } - public IXLStyle WhenEquals(String value) + public IXLStyle WhenEquals(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.Equal; @@ -343,7 +361,7 @@ public IXLStyle WhenEquals(String value) return Style; } - public IXLStyle WhenNotEquals(String value) + public IXLStyle WhenNotEquals(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.NotEqual; @@ -351,7 +369,7 @@ public IXLStyle WhenNotEquals(String value) return Style; } - public IXLStyle WhenGreaterThan(String value) + public IXLStyle WhenGreaterThan(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.GreaterThan; @@ -359,7 +377,7 @@ public IXLStyle WhenGreaterThan(String value) return Style; } - public IXLStyle WhenLessThan(String value) + public IXLStyle WhenLessThan(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.LessThan; @@ -367,7 +385,7 @@ public IXLStyle WhenLessThan(String value) return Style; } - public IXLStyle WhenEqualOrGreaterThan(String value) + public IXLStyle WhenEqualOrGreaterThan(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.EqualOrGreaterThan; @@ -375,7 +393,7 @@ public IXLStyle WhenEqualOrGreaterThan(String value) return Style; } - public IXLStyle WhenEqualOrLessThan(String value) + public IXLStyle WhenEqualOrLessThan(string value) { Values.Initialize(new XLFormula { Value = value }); Operator = XLCFOperator.EqualOrLessThan; @@ -383,7 +401,7 @@ public IXLStyle WhenEqualOrLessThan(String value) return Style; } - public IXLStyle WhenBetween(String minValue, String maxValue) + public IXLStyle WhenBetween(string minValue, string maxValue) { Values.Initialize(new XLFormula { Value = minValue }); Values.Add(new XLFormula { Value = maxValue }); @@ -392,7 +410,7 @@ public IXLStyle WhenBetween(String minValue, String maxValue) return Style; } - public IXLStyle WhenNotBetween(String minValue, String maxValue) + public IXLStyle WhenNotBetween(string minValue, string maxValue) { Values.Initialize(new XLFormula { Value = minValue }); Values.Add(new XLFormula { Value = maxValue }); @@ -401,7 +419,7 @@ public IXLStyle WhenNotBetween(String minValue, String maxValue) return Style; } - public IXLStyle WhenEquals(Double value) + public IXLStyle WhenEquals(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.Equal; @@ -409,7 +427,7 @@ public IXLStyle WhenEquals(Double value) return Style; } - public IXLStyle WhenNotEquals(Double value) + public IXLStyle WhenNotEquals(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.NotEqual; @@ -417,7 +435,7 @@ public IXLStyle WhenNotEquals(Double value) return Style; } - public IXLStyle WhenGreaterThan(Double value) + public IXLStyle WhenGreaterThan(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.GreaterThan; @@ -425,7 +443,7 @@ public IXLStyle WhenGreaterThan(Double value) return Style; } - public IXLStyle WhenLessThan(Double value) + public IXLStyle WhenLessThan(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.LessThan; @@ -433,7 +451,7 @@ public IXLStyle WhenLessThan(Double value) return Style; } - public IXLStyle WhenEqualOrGreaterThan(Double value) + public IXLStyle WhenEqualOrGreaterThan(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.EqualOrGreaterThan; @@ -441,7 +459,7 @@ public IXLStyle WhenEqualOrGreaterThan(Double value) return Style; } - public IXLStyle WhenEqualOrLessThan(Double value) + public IXLStyle WhenEqualOrLessThan(double value) { Values.Initialize(new XLFormula(value)); Operator = XLCFOperator.EqualOrLessThan; @@ -449,7 +467,7 @@ public IXLStyle WhenEqualOrLessThan(Double value) return Style; } - public IXLStyle WhenBetween(Double minValue, Double maxValue) + public IXLStyle WhenBetween(double minValue, double maxValue) { Values.Initialize(new XLFormula(minValue)); Values.Add(new XLFormula(maxValue)); @@ -458,7 +476,7 @@ public IXLStyle WhenBetween(Double minValue, Double maxValue) return Style; } - public IXLStyle WhenNotBetween(Double minValue, Double maxValue) + public IXLStyle WhenNotBetween(double minValue, double maxValue) { Values.Initialize(new XLFormula(minValue)); Values.Add(new XLFormula(maxValue)); @@ -479,15 +497,15 @@ public IXLStyle WhenIsUnique() return Style; } - public IXLStyle WhenIsTrue(String formula) + public IXLStyle WhenIsTrue(string formula) { - String f = formula.TrimStart()[0] == '=' ? formula : "=" + formula; + var f = formula.TrimStart()[0] == '=' ? formula : "=" + formula; Values.Initialize(new XLFormula { Value = f }); ConditionalFormatType = XLConditionalFormatType.Expression; return Style; } - public IXLStyle WhenIsTop(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items) + public IXLStyle WhenIsTop(int value, XLTopBottomType topBottomType = XLTopBottomType.Items) { Values.Initialize(new XLFormula(value)); Percent = topBottomType == XLTopBottomType.Percent; @@ -496,7 +514,7 @@ public IXLStyle WhenIsTop(Int32 value, XLTopBottomType topBottomType = XLTopBott return Style; } - public IXLStyle WhenIsBottom(Int32 value, XLTopBottomType topBottomType = XLTopBottomType.Items) + public IXLStyle WhenIsBottom(int value, XLTopBottomType topBottomType = XLTopBottomType.Items) { Values.Initialize(new XLFormula(value)); Percent = topBottomType == XLTopBottomType.Percent; @@ -511,7 +529,7 @@ public IXLCFColorScaleMin ColorScale() return new XLCFColorScaleMin(this); } - public IXLCFDataBarMin DataBar(XLColor color, Boolean showBarOnly = false) + public IXLCFDataBarMin DataBar(XLColor color, bool showBarOnly = false) { Colors.Initialize(color); ShowBarOnly = showBarOnly; @@ -519,7 +537,7 @@ public IXLCFDataBarMin DataBar(XLColor color, Boolean showBarOnly = false) return new XLCFDataBarMin(this); } - public IXLCFDataBarMin DataBar(XLColor positiveColor, XLColor negativeColor, Boolean showBarOnly = false) + public IXLCFDataBarMin DataBar(XLColor positiveColor, XLColor negativeColor, bool showBarOnly = false) { Colors.Initialize(positiveColor); Colors.Add(negativeColor); @@ -528,7 +546,7 @@ public IXLCFDataBarMin DataBar(XLColor positiveColor, XLColor negativeColor, Boo return new XLCFDataBarMin(this); } - public IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, Boolean reverseIconOrder = false, Boolean showIconOnly = false) + public IXLCFIconSet IconSet(XLIconSetStyle iconSetStyle, bool reverseIconOrder = false, bool showIconOnly = false) { IconSetOperators.Clear(); Values.Clear(); @@ -548,20 +566,34 @@ internal class DictionaryComparer : public DictionaryComparer(IEqualityComparer valueComparer = null) { - this._valueComparer = valueComparer ?? EqualityComparer.Default; + _valueComparer = valueComparer ?? EqualityComparer.Default; } public bool Equals(Dictionary x, Dictionary y) { if (x.Count != y.Count) + { return false; + } + if (x.Keys.Except(y.Keys).Any()) + { return false; + } + if (y.Keys.Except(x.Keys).Any()) + { return false; + } + foreach (var pair in x) + { if (!_valueComparer.Equals(pair.Value, y[pair.Key])) + { return false; + } + } + return true; } @@ -577,7 +609,7 @@ internal class EnumerableComparer : IEqualityComparer> public EnumerableComparer(IEqualityComparer valueComparer = null) { - this._valueComparer = valueComparer ?? EqualityComparer.Default; + _valueComparer = valueComparer ?? EqualityComparer.Default; } public bool Equals(IEnumerable x, IEnumerable y) diff --git a/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs b/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs index 5a000f64b..c83776ddf 100644 --- a/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs +++ b/ClosedXML/Excel/ConditionalFormats/XLConditionalFormats.cs @@ -59,7 +59,7 @@ internal void Consolidate() item.Ranges.ForEach(r => rangesToJoin.Add(r)); var firstRange = item.Ranges.First(); var skippedRanges = new XLRanges(); - Func IsSameFormat = f => + bool IsSameFormat(IXLConditionalFormat f) => f != item && f.Ranges.First().Worksheet.Position == firstRange.Worksheet.Position && XLConditionalFormat.NoRangeComparer.Equals(f, item); @@ -70,12 +70,12 @@ internal void Consolidate() false, false); var baseCell = firstRange.Worksheet.Cell(baseAddress) as XLCell; - int i = 1; - bool stop = false; - List similarFormats = new List(); + var i = 1; + var stop = false; + var similarFormats = new List(); do { - stop = (i >= formats.Count); + stop = i >= formats.Count; if (!stop) { @@ -99,7 +99,9 @@ internal void Consolidate() } if (!isSameFormat) + { nextFormat.Ranges.ForEach(r => skippedRanges.Add(r)); + } } i++; diff --git a/ClosedXML/Excel/ContentManagers/XLBaseContentManager.cs b/ClosedXML/Excel/ContentManagers/XLBaseContentManager.cs index 6d031b5d8..8302103f0 100644 --- a/ClosedXML/Excel/ContentManagers/XLBaseContentManager.cs +++ b/ClosedXML/Excel/ContentManagers/XLBaseContentManager.cs @@ -25,9 +25,13 @@ public OpenXmlElement GetPreviousElementFor(T content) .OrderBy(key => key.CastTo()); if (previousElements.Any()) + { return contents[previousElements.Last()]; + } else + { return null; + } } public void SetElement(T content, OpenXmlElement element) diff --git a/ClosedXML/Excel/Coordinates/IXLAddress.cs b/ClosedXML/Excel/Coordinates/IXLAddress.cs index 6158251d0..7a5e70f58 100644 --- a/ClosedXML/Excel/Coordinates/IXLAddress.cs +++ b/ClosedXML/Excel/Coordinates/IXLAddress.cs @@ -5,27 +5,27 @@ namespace ClosedXML.Excel { public interface IXLAddress : IEqualityComparer, IEquatable { - String ColumnLetter { get; } - Int32 ColumnNumber { get; } - Boolean FixedColumn { get; } - Boolean FixedRow { get; } - Int32 RowNumber { get; } - String UniqueId { get; } + string ColumnLetter { get; } + int ColumnNumber { get; } + bool FixedColumn { get; } + bool FixedRow { get; } + int RowNumber { get; } + string UniqueId { get; } IXLWorksheet Worksheet { get; } - String ToString(XLReferenceStyle referenceStyle); + string ToString(XLReferenceStyle referenceStyle); - String ToString(XLReferenceStyle referenceStyle, Boolean includeSheet); + string ToString(XLReferenceStyle referenceStyle, bool includeSheet); - String ToStringFixed(); + string ToStringFixed(); - String ToStringFixed(XLReferenceStyle referenceStyle); + string ToStringFixed(XLReferenceStyle referenceStyle); - String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeSheet); + string ToStringFixed(XLReferenceStyle referenceStyle, bool includeSheet); - String ToStringRelative(); + string ToStringRelative(); - String ToStringRelative(Boolean includeSheet); + string ToStringRelative(bool includeSheet); } } diff --git a/ClosedXML/Excel/Coordinates/XLAddress.cs b/ClosedXML/Excel/Coordinates/XLAddress.cs index 11d34d105..54d7b5765 100644 --- a/ClosedXML/Excel/Coordinates/XLAddress.cs +++ b/ClosedXML/Excel/Coordinates/XLAddress.cs @@ -1,4 +1,3 @@ -using ClosedXML.Extensions; using System; using System.Diagnostics; @@ -7,6 +6,7 @@ namespace ClosedXML.Excel internal struct XLAddress : IXLAddress, IEquatable { #region Static + /// /// Create address without worksheet. For calculation only! /// @@ -20,7 +20,7 @@ public static XLAddress Create(string cellAddressString) public static XLAddress Create(XLWorksheet worksheet, string cellAddressString) { var fixedColumn = cellAddressString[0] == '$'; - Int32 startPos; + int startPos; if (fixedColumn) { startPos = 1; @@ -30,7 +30,7 @@ public static XLAddress Create(XLWorksheet worksheet, string cellAddressString) startPos = 0; } - int rowPos = startPos; + var rowPos = startPos; while (cellAddressString[rowPos] > '9') { rowPos++; @@ -63,7 +63,7 @@ public static XLAddress Create(XLWorksheet worksheet, string cellAddressString) columnLetter = cellAddressString.Substring(startPos, rowPos); } - rowNumber = Int32.Parse(cellAddressString.Substring(rowPos), XLHelper.NumberStyle, XLHelper.ParseCulture); + rowNumber = int.Parse(cellAddressString.Substring(rowPos), XLHelper.NumberStyle, XLHelper.ParseCulture); } return new XLAddress(worksheet, rowNumber, columnLetter, fixedRow, fixedColumn); } @@ -73,10 +73,10 @@ public static XLAddress Create(XLWorksheet worksheet, string cellAddressString) #region Private fields [DebuggerBrowsable(DebuggerBrowsableState.Never)] - private bool _fixedRow; + private readonly bool _fixedRow; [DebuggerBrowsable(DebuggerBrowsableState.Never)] - private bool _fixedColumn; + private readonly bool _fixedColumn; [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly int _rowNumber; @@ -164,39 +164,24 @@ public bool HasWorksheet get { return Worksheet != null; } } - public bool FixedRow - { - get { return _fixedRow; } - } + public bool FixedRow => _fixedRow; - public bool FixedColumn - { - get { return _fixedColumn; } - } + public bool FixedColumn => _fixedColumn; /// /// Gets the row number of this address. /// - public Int32 RowNumber - { - get { return _rowNumber; } - } + public int RowNumber => _rowNumber; /// /// Gets the column number of this address. /// - public Int32 ColumnNumber - { - get { return _columnNumber; } - } + public int ColumnNumber => _columnNumber; /// /// Gets the column letter(s) of this address. /// - public String ColumnLetter - { - get { return XLHelper.GetColumnLetterFromNumber(_columnNumber); } - } + public string ColumnLetter => XLHelper.GetColumnLetterFromNumber(_columnNumber); #endregion Properties @@ -205,9 +190,11 @@ public String ColumnLetter public override string ToString() { if (!IsValid) + { return "#REF!"; + } - String retVal = ColumnLetter; + var retVal = ColumnLetter; if (_fixedColumn) { retVal = "$" + retVal; @@ -229,20 +216,30 @@ public string ToString(XLReferenceStyle referenceStyle, bool includeSheet) { string address; if (!IsValid) + { address = "#REF!"; + } else if (referenceStyle == XLReferenceStyle.A1) + { address = GetTrimmedAddress(); + } else if (referenceStyle == XLReferenceStyle.R1C1 || HasWorksheet && Worksheet.Workbook.ReferenceStyle == XLReferenceStyle.R1C1) + { address = "R" + _rowNumber.ToInvariantString() + "C" + ColumnNumber.ToInvariantString(); + } else + { address = GetTrimmedAddress(); + } if (includeSheet) - return String.Concat( + { + return string.Concat( WorksheetIsDeleted ? "#REF" : Worksheet.Name.EscapeSheetName(), '!', address); + } return address; } @@ -253,7 +250,7 @@ public string ToString(XLReferenceStyle referenceStyle, bool includeSheet) public string GetTrimmedAddress() { - return _trimmedAddress ?? (_trimmedAddress = ColumnLetter + _rowNumber.ToInvariantString()); + return _trimmedAddress ??= ColumnLetter + _rowNumber.ToInvariantString(); } #endregion Methods @@ -278,7 +275,7 @@ public string GetTrimmedAddress() left._fixedColumn); } - public static XLAddress operator +(XLAddress left, Int32 right) + public static XLAddress operator +(XLAddress left, int right) { return new XLAddress(left.Worksheet, left.RowNumber + right, @@ -287,7 +284,7 @@ public string GetTrimmedAddress() left._fixedColumn); } - public static XLAddress operator -(XLAddress left, Int32 right) + public static XLAddress operator -(XLAddress left, int right) { return new XLAddress(left.Worksheet, left.RowNumber - right, @@ -296,16 +293,12 @@ public string GetTrimmedAddress() left._fixedColumn); } - public static Boolean operator ==(XLAddress left, XLAddress right) + public static bool operator ==(XLAddress left, XLAddress right) { - if (ReferenceEquals(left, right)) - { - return true; - } - return !ReferenceEquals(left, null) && left.Equals(right); + return object.Equals(left, right); } - public static Boolean operator !=(XLAddress left, XLAddress right) + public static bool operator !=(XLAddress left, XLAddress right) { return !(left == right); } @@ -316,12 +309,12 @@ public string GetTrimmedAddress() #region IEqualityComparer Members - public Boolean Equals(IXLAddress x, IXLAddress y) + public bool Equals(IXLAddress x, IXLAddress y) { return x == y; } - public new Boolean Equals(object x, object y) + public new bool Equals(object x, object y) { return x == y; } @@ -333,7 +326,9 @@ public Boolean Equals(IXLAddress x, IXLAddress y) public bool Equals(IXLAddress other) { if (other == null) + { return false; + } return _rowNumber == other.RowNumber && _columnNumber == other.ColumnNumber && @@ -349,9 +344,9 @@ public bool Equals(XLAddress other) _fixedColumn == other._fixedColumn; } - public override Boolean Equals(Object other) + public override bool Equals(object obj) { - return Equals(other as IXLAddress); + return Equals(obj as IXLAddress); } public override int GetHashCode() @@ -373,26 +368,28 @@ public int GetHashCode(IXLAddress obj) #endregion Interface Requirements - public String ToStringRelative() + public string ToStringRelative() { return ToStringRelative(false); } - public String ToStringFixed() + public string ToStringFixed() { return ToStringFixed(XLReferenceStyle.Default); } - public String ToStringRelative(Boolean includeSheet) + public string ToStringRelative(bool includeSheet) { var address = IsValid ? GetTrimmedAddress() : "#REF!"; if (includeSheet) - return String.Concat( + { + return string.Concat( WorksheetIsDeleted ? "#REF" : Worksheet.Name.EscapeSheetName(), '!', address ); + } return address; } @@ -402,20 +399,24 @@ internal XLAddress WithoutWorksheet() return new XLAddress(RowNumber, ColumnNumber, FixedRow, FixedColumn); } - public String ToStringFixed(XLReferenceStyle referenceStyle) + public string ToStringFixed(XLReferenceStyle referenceStyle) { return ToStringFixed(referenceStyle, false); } - public String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeSheet) + public string ToStringFixed(XLReferenceStyle referenceStyle, bool includeSheet) { - String address; + string address; if (referenceStyle == XLReferenceStyle.Default && HasWorksheet) + { referenceStyle = Worksheet.Workbook.ReferenceStyle; + } if (referenceStyle == XLReferenceStyle.Default) + { referenceStyle = XLReferenceStyle.A1; + } Debug.Assert(referenceStyle != XLReferenceStyle.Default); @@ -428,11 +429,11 @@ public String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeShee switch (referenceStyle) { case XLReferenceStyle.A1: - address = String.Concat('$', ColumnLetter, '$', _rowNumber.ToInvariantString()); + address = string.Concat('$', ColumnLetter, '$', _rowNumber.ToInvariantString()); break; case XLReferenceStyle.R1C1: - address = String.Concat('R', _rowNumber.ToInvariantString(), 'C', ColumnNumber); + address = string.Concat('R', _rowNumber.ToInvariantString(), 'C', ColumnNumber); break; default: @@ -441,25 +442,21 @@ public String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeShee } if (includeSheet) - return String.Concat( + { + return string.Concat( WorksheetIsDeleted ? "#REF" : Worksheet.Name.EscapeSheetName(), '!', address); + } return address; } - public String UniqueId { get { return RowNumber.ToString("0000000") + ColumnNumber.ToString("00000"); } } + public string UniqueId => RowNumber.ToString("0000000") + ColumnNumber.ToString("00000"); - public bool IsValid - { - get - { - return 0 < RowNumber && RowNumber <= XLHelper.MaxRowNumber && + public bool IsValid => 0 < RowNumber && RowNumber <= XLHelper.MaxRowNumber && 0 < ColumnNumber && ColumnNumber <= XLHelper.MaxColumnNumber; - } - } private bool WorksheetIsDeleted => Worksheet?.IsDeleted == true; } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Coordinates/XLSheetPoint.cs b/ClosedXML/Excel/Coordinates/XLSheetPoint.cs index f1c3cea23..41a852723 100644 --- a/ClosedXML/Excel/Coordinates/XLSheetPoint.cs +++ b/ClosedXML/Excel/Coordinates/XLSheetPoint.cs @@ -4,14 +4,14 @@ namespace ClosedXML.Excel { internal struct XLSheetPoint:IEquatable { - public XLSheetPoint(Int32 row, Int32 column) + public XLSheetPoint(int row, int column) { Row = row; Column = column; } - public readonly Int32 Row; - public readonly Int32 Column; + public readonly int Row; + public readonly int Column; public override bool Equals(object obj) { diff --git a/ClosedXML/Excel/CustomProperties/IXLCustomProperties.cs b/ClosedXML/Excel/CustomProperties/IXLCustomProperties.cs index 83e906a5c..0d1810e53 100644 --- a/ClosedXML/Excel/CustomProperties/IXLCustomProperties.cs +++ b/ClosedXML/Excel/CustomProperties/IXLCustomProperties.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -6,9 +5,9 @@ namespace ClosedXML.Excel public interface IXLCustomProperties: IEnumerable { void Add(IXLCustomProperty customProperty); - void Add(String name, T value); - void Delete(String name); - IXLCustomProperty CustomProperty(String name); + void Add(string name, T value); + void Delete(string name); + IXLCustomProperty CustomProperty(string name); } } diff --git a/ClosedXML/Excel/CustomProperties/IXLCustomProperty.cs b/ClosedXML/Excel/CustomProperties/IXLCustomProperty.cs index cfed06ed9..dcd72f255 100644 --- a/ClosedXML/Excel/CustomProperties/IXLCustomProperty.cs +++ b/ClosedXML/Excel/CustomProperties/IXLCustomProperty.cs @@ -1,13 +1,11 @@ -using System; - namespace ClosedXML.Excel { public enum XLCustomPropertyType { Text, Number, Date, Boolean} public interface IXLCustomProperty { - String Name { get; set; } + string Name { get; set; } XLCustomPropertyType Type { get; } - Object Value { get; set; } + object Value { get; set; } T GetValue(); } } diff --git a/ClosedXML/Excel/CustomProperties/XLCustomProperties.cs b/ClosedXML/Excel/CustomProperties/XLCustomProperties.cs index 0322069c1..62d02c515 100644 --- a/ClosedXML/Excel/CustomProperties/XLCustomProperties.cs +++ b/ClosedXML/Excel/CustomProperties/XLCustomProperties.cs @@ -1,32 +1,31 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel { internal class XLCustomProperties: IXLCustomProperties, IEnumerable { - XLWorkbook workbook; + readonly XLWorkbook workbook; public XLCustomProperties(XLWorkbook workbook) { this.workbook = workbook; } - private Dictionary customProperties = new Dictionary(); + private readonly Dictionary customProperties = new Dictionary(); public void Add(IXLCustomProperty customProperty) { customProperties.Add(customProperty.Name, customProperty); } - public void Add(String name, T value) + public void Add(string name, T value) { var cp = new XLCustomProperty(workbook) { Name = name, Value = value }; Add(cp); } - public void Delete(String name) + public void Delete(string name) { customProperties.Remove(name); } - public IXLCustomProperty CustomProperty(String name) + public IXLCustomProperty CustomProperty(string name) { return customProperties[name]; } diff --git a/ClosedXML/Excel/CustomProperties/XLCustomProperty.cs b/ClosedXML/Excel/CustomProperties/XLCustomProperty.cs index a1d4d19cd..432ba70d7 100644 --- a/ClosedXML/Excel/CustomProperties/XLCustomProperty.cs +++ b/ClosedXML/Excel/CustomProperties/XLCustomProperty.cs @@ -7,7 +7,7 @@ internal class XLCustomProperty : IXLCustomProperty { private readonly XLWorkbook _workbook; - private String name; + private string name; public XLCustomProperty(XLWorkbook workbook) { @@ -16,16 +16,21 @@ public XLCustomProperty(XLWorkbook workbook) #region IXLCustomProperty Members - public String Name + public string Name { get { return name; } set { - if (name == value) return; + if (name == value) + { + return; + } if (_workbook.CustomProperties.Any(t => t.Name == value)) + { throw new ArgumentException( - String.Format("This workbook already contains a custom property named '{0}'", value)); + string.Format("This workbook already contains a custom property named '{0}'", value)); + } name = value; } @@ -36,19 +41,25 @@ public XLCustomPropertyType Type get { if (Value is DateTime) + { return XLCustomPropertyType.Date; - - if (Value is Boolean) + } + + if (Value is bool) + { return XLCustomPropertyType.Boolean; - - if (Double.TryParse(Value.ToString(), out Double dTest)) + } + + if (double.TryParse(Value.ToString(), out var dTest)) + { return XLCustomPropertyType.Number; - + } + return XLCustomPropertyType.Text; } } - public Object Value { get; set; } + public object Value { get; set; } public T GetValue() { diff --git a/ClosedXML/Excel/DataValidation/IXLDataValidation.cs b/ClosedXML/Excel/DataValidation/IXLDataValidation.cs index 05e176e02..f8507b756 100644 --- a/ClosedXML/Excel/DataValidation/IXLDataValidation.cs +++ b/ClosedXML/Excel/DataValidation/IXLDataValidation.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -18,23 +17,23 @@ public interface IXLDataValidation XLDecimalCriteria Decimal { get; } - String ErrorMessage { get; set; } + string ErrorMessage { get; set; } XLErrorStyle ErrorStyle { get; set; } - String ErrorTitle { get; set; } + string ErrorTitle { get; set; } - Boolean IgnoreBlanks { get; set; } + bool IgnoreBlanks { get; set; } - Boolean InCellDropdown { get; set; } + bool InCellDropdown { get; set; } - String InputMessage { get; set; } + string InputMessage { get; set; } - String InputTitle { get; set; } + string InputTitle { get; set; } - String MaxValue { get; set; } + string MaxValue { get; set; } - String MinValue { get; set; } + string MinValue { get; set; } XLOperator Operator { get; set; } @@ -43,17 +42,17 @@ public interface IXLDataValidation /// IEnumerable Ranges { get; } - Boolean ShowErrorMessage { get; set; } + bool ShowErrorMessage { get; set; } //void Delete(); //void CopyFrom(IXLDataValidation dataValidation); - Boolean ShowInputMessage { get; set; } + bool ShowInputMessage { get; set; } XLTextLengthCriteria TextLength { get; } XLTimeCriteria Time { get; } - String Value { get; set; } + string Value { get; set; } XLWholeNumberCriteria WholeNumber { get; } @@ -80,17 +79,17 @@ public interface IXLDataValidation /// void ClearRanges(); - void Custom(String customValidation); + void Custom(string customValidation); - Boolean IsDirty(); + bool IsDirty(); - void List(String list); + void List(string list); - void List(String list, Boolean inCellDropdown); + void List(string list, bool inCellDropdown); void List(IXLRange range); - void List(IXLRange range, Boolean inCellDropdown); + void List(IXLRange range, bool inCellDropdown); /// /// Remove the specified range from the collection of range this rule applies to. diff --git a/ClosedXML/Excel/DataValidation/IXLDataValidations.cs b/ClosedXML/Excel/DataValidation/IXLDataValidations.cs index 919d6883a..44ec35c19 100644 --- a/ClosedXML/Excel/DataValidation/IXLDataValidations.cs +++ b/ClosedXML/Excel/DataValidation/IXLDataValidations.cs @@ -19,7 +19,7 @@ public interface IXLDataValidations : IEnumerable /// (may be a copy of the specified one). IXLDataValidation Add(IXLDataValidation dataValidation); - Boolean ContainsSingle(IXLRange range); + bool ContainsSingle(IXLRange range); void Delete(Predicate predicate); diff --git a/ClosedXML/Excel/DataValidation/IXLValidationCriteria.cs b/ClosedXML/Excel/DataValidation/IXLValidationCriteria.cs index e1328bd2a..6ab581ec3 100644 --- a/ClosedXML/Excel/DataValidation/IXLValidationCriteria.cs +++ b/ClosedXML/Excel/DataValidation/IXLValidationCriteria.cs @@ -5,56 +5,56 @@ namespace ClosedXML.Excel { public interface IXLValidationCriteria { - void Between(String minValue, String maxValue); + void Between(string minValue, string maxValue); [Obsolete("Use the overload accepting IXLCell")] void Between(IXLRange minValue, IXLRange maxValue); void Between(IXLCell minValue, IXLCell maxValue); - void EqualOrGreaterThan(String value); + void EqualOrGreaterThan(string value); [Obsolete("Use the overload accepting IXLCell")] void EqualOrGreaterThan(IXLRange range); void EqualOrGreaterThan(IXLCell cell); - void EqualOrLessThan(String value); + void EqualOrLessThan(string value); [Obsolete("Use the overload accepting IXLCell")] void EqualOrLessThan(IXLRange range); void EqualOrLessThan(IXLCell cell); - void EqualTo(String value); + void EqualTo(string value); [Obsolete("Use the overload accepting IXLCell")] void EqualTo(IXLRange range); void EqualTo(IXLCell cell); - void GreaterThan(String value); + void GreaterThan(string value); [Obsolete("Use the overload accepting IXLCell")] void GreaterThan(IXLRange range); void GreaterThan(IXLCell cell); - void LessThan(String value); + void LessThan(string value); [Obsolete("Use the overload accepting IXLCell")] void LessThan(IXLRange range); void LessThan(IXLCell cell); - void NotBetween(String minValue, String maxValue); + void NotBetween(string minValue, string maxValue); [Obsolete("Use the overload accepting IXLCell")] void NotBetween(IXLRange minValue, IXLRange maxValue); void NotBetween(IXLCell minValue, IXLCell maxValue); - void NotEqualTo(String value); + void NotEqualTo(string value); [Obsolete("Use the overload accepting IXLCell")] void NotEqualTo(IXLRange range); diff --git a/ClosedXML/Excel/DataValidation/XLDataValidation.cs b/ClosedXML/Excel/DataValidation/XLDataValidation.cs index 234164789..065a871d9 100644 --- a/ClosedXML/Excel/DataValidation/XLDataValidation.cs +++ b/ClosedXML/Excel/DataValidation/XLDataValidation.cs @@ -1,4 +1,5 @@ // Keep this file CodeMaid organised and cleaned +using ClosedXML.Excel.Ranges; using System; using System.Collections.Generic; using System.Linq; @@ -23,7 +24,10 @@ internal class XLDataValidation : IXLDataValidation public XLDataValidation(IXLRange range) : this(range?.Worksheet as XLWorksheet) { - if (range == null) throw new ArgumentNullException(nameof(range)); + if (range == null) + { + throw new ArgumentNullException(nameof(range)); + } AddRange(range); } @@ -55,10 +59,15 @@ public void Clear() public void CopyFrom(IXLDataValidation dataValidation) { - if (dataValidation == this) return; + if (dataValidation == this) + { + return; + } if (!_ranges.Any()) + { AddRanges(dataValidation.Ranges); + } IgnoreBlanks = dataValidation.IgnoreBlanks; InCellDropdown = dataValidation.InCellDropdown; @@ -75,14 +84,14 @@ public void CopyFrom(IXLDataValidation dataValidation) MaxValue = dataValidation.MaxValue; } - public Boolean IsDirty() + public bool IsDirty() { return AllowedValues != XLAllowedValues.AnyValue || (ShowInputMessage && - (!String.IsNullOrWhiteSpace(InputTitle) || !String.IsNullOrWhiteSpace(InputMessage))) + (!string.IsNullOrWhiteSpace(InputTitle) || !string.IsNullOrWhiteSpace(InputMessage))) || (ShowErrorMessage && - (!String.IsNullOrWhiteSpace(ErrorTitle) || !String.IsNullOrWhiteSpace(ErrorMessage))); + (!string.IsNullOrWhiteSpace(ErrorTitle) || !string.IsNullOrWhiteSpace(ErrorMessage))); } internal void SplitBy(IXLRangeAddress rangeAddress) @@ -104,21 +113,21 @@ private void Initialize() ShowErrorMessage = true; ShowInputMessage = true; InCellDropdown = true; - InputTitle = String.Empty; - InputMessage = String.Empty; - ErrorTitle = String.Empty; - ErrorMessage = String.Empty; + InputTitle = string.Empty; + InputMessage = string.Empty; + ErrorTitle = string.Empty; + ErrorMessage = string.Empty; ErrorStyle = XLErrorStyle.Stop; Operator = XLOperator.Between; - Value = String.Empty; - MinValue = String.Empty; - MaxValue = String.Empty; + Value = string.Empty; + MinValue = string.Empty; + MaxValue = string.Empty; } #region IXLDataValidation Members - private String maxValue; - private String minValue; + private string maxValue; + private string minValue; public XLAllowedValues AllowedValues { get; set; } public XLDateCriteria Date @@ -139,21 +148,21 @@ public XLDecimalCriteria Decimal } } - public String ErrorMessage { get; set; } + public string ErrorMessage { get; set; } public XLErrorStyle ErrorStyle { get; set; } - public String ErrorTitle { get; set; } - public Boolean IgnoreBlanks { get; set; } - public Boolean InCellDropdown { get; set; } - public String InputMessage { get; set; } - public String InputTitle { get; set; } - public String MaxValue { get => maxValue; set { Validate(value); maxValue = value; } } - public String MinValue { get => minValue; set { Validate(value); minValue = value; } } + public string ErrorTitle { get; set; } + public bool IgnoreBlanks { get; set; } + public bool InCellDropdown { get; set; } + public string InputMessage { get; set; } + public string InputTitle { get; set; } + public string MaxValue { get => maxValue; set { Validate(value); maxValue = value; } } + public string MinValue { get => minValue; set { Validate(value); minValue = value; } } public XLOperator Operator { get; set; } public IEnumerable Ranges => _ranges.AsEnumerable(); - public Boolean ShowErrorMessage { get; set; } + public bool ShowErrorMessage { get; set; } - public Boolean ShowInputMessage { get; set; } + public bool ShowInputMessage { get; set; } public XLTextLengthCriteria TextLength { @@ -173,7 +182,7 @@ public XLTimeCriteria Time } } - public String Value + public string Value { get { return MinValue; } set { MinValue = value; } @@ -196,10 +205,15 @@ public XLWholeNumberCriteria WholeNumber /// A range to add. public void AddRange(IXLRange range) { - if (range == null) throw new ArgumentNullException(nameof(range)); + if (range == null) + { + throw new ArgumentNullException(nameof(range)); + } if (range.Worksheet != Worksheet) + { range = Worksheet.Range(((XLRangeAddress)range.RangeAddress).WithoutWorksheet()); + } _ranges.Add(range); @@ -236,18 +250,18 @@ public void ClearRanges() } } - public void Custom(String customValidation) + public void Custom(string customValidation) { AllowedValues = XLAllowedValues.Custom; Value = customValidation; } - public void List(String list) + public void List(string list) { List(list, true); } - public void List(String list, Boolean inCellDropdown) + public void List(string list, bool inCellDropdown) { AllowedValues = XLAllowedValues.List; InCellDropdown = inCellDropdown; @@ -259,7 +273,7 @@ public void List(IXLRange range) List(range, true); } - public void List(IXLRange range, Boolean inCellDropdown) + public void List(IXLRange range, bool inCellDropdown) { List(range.RangeAddress.ToStringFixed(XLReferenceStyle.A1, true)); } @@ -271,7 +285,9 @@ public void List(IXLRange range, Boolean inCellDropdown) public bool RemoveRange(IXLRange range) { if (range == null) + { return false; + } var res = _ranges.Remove(range); @@ -285,10 +301,12 @@ public bool RemoveRange(IXLRange range) #endregion IXLDataValidation Members - private void Validate(String value) + private void Validate(string value) { if (value.Length > 255) + { throw new ArgumentOutOfRangeException(nameof(value), "The maximum allowed length of the value is 255 characters."); + } } } } diff --git a/ClosedXML/Excel/DataValidation/XLDataValidations.cs b/ClosedXML/Excel/DataValidation/XLDataValidations.cs index 14a92baef..985368419 100644 --- a/ClosedXML/Excel/DataValidation/XLDataValidations.cs +++ b/ClosedXML/Excel/DataValidation/XLDataValidations.cs @@ -2,12 +2,11 @@ using ClosedXML.Excel.Ranges.Index; using System; using System.Collections.Generic; +using System.Collections; +using System.Linq; namespace ClosedXML.Excel { - using System.Collections; - using System.Linq; - internal class XLDataValidations : IXLDataValidations { private readonly XLRangeIndex _dataValidationIndex; @@ -19,7 +18,7 @@ internal class XLDataValidations : IXLDataValidations /// The flag used to avoid unnecessary check for splitting intersected ranges when we already /// are performing the splitting. /// - private bool _skipSplittingExistingRanges = false; + private bool _skipSplittingExistingRanges; public XLDataValidations(XLWorksheet worksheet) { @@ -38,13 +37,16 @@ public IXLDataValidation Add(IXLDataValidation dataValidation) return Add(dataValidation, skipIntersectionsCheck: false); } - public Boolean ContainsSingle(IXLRange range) + public bool ContainsSingle(IXLRange range) { - Int32 count = 0; + var count = 0; foreach (var xlDataValidation in _dataValidations.Where(dv => dv.Ranges.Contains(range))) { count++; - if (count > 1) return false; + if (count > 1) + { + return false; + } } return count == 1; @@ -61,7 +63,10 @@ public void Delete(Predicate predicate) public void Delete(IXLDataValidation dataValidation) { if (!_dataValidations.Remove(dataValidation)) + { return; + } + var xlDataValidation = dataValidation as XLDataValidation; xlDataValidation.RangeAdded -= OnRangeAdded; xlDataValidation.RangeRemoved -= OnRangeRemoved; @@ -74,7 +79,10 @@ public void Delete(IXLDataValidation dataValidation) public void Delete(IXLRange range) { - if (range == null) throw new ArgumentNullException(nameof(range)); + if (range == null) + { + throw new ArgumentNullException(nameof(range)); + } var dataValidationsToRemove = _dataValidationIndex.GetIntersectedRanges((XLRangeAddress)range.RangeAddress) .Select(e => e.DataValidation) @@ -90,7 +98,9 @@ public void Delete(IXLRange range) public IEnumerable GetAllInRange(IXLRangeAddress rangeAddress) { if (rangeAddress == null || !rangeAddress.IsValid) + { return Enumerable.Empty(); + } return _dataValidationIndex.GetIntersectedRanges((XLRangeAddress)rangeAddress) .Select(indexEntry => indexEntry.DataValidation) @@ -120,14 +130,18 @@ public bool TryGet(IXLRangeAddress rangeAddress, out IXLDataValidation dataValid { dataValidation = null; if (rangeAddress == null || !rangeAddress.IsValid) + { return false; + } var candidates = _dataValidationIndex.GetIntersectedRanges((XLRangeAddress)rangeAddress) .Where(c => c.RangeAddress.Contains(rangeAddress.FirstAddress) && c.RangeAddress.Contains(rangeAddress.LastAddress)); if (!candidates.Any()) + { return false; + } dataValidation = candidates.First().DataValidation; @@ -136,7 +150,10 @@ public bool TryGet(IXLRangeAddress rangeAddress, out IXLDataValidation dataValid internal IXLDataValidation Add(IXLDataValidation dataValidation, bool skipIntersectionsCheck) { - if (dataValidation == null) throw new ArgumentNullException(nameof(dataValidation)); + if (dataValidation == null) + { + throw new ArgumentNullException(nameof(dataValidation)); + } XLDataValidation xlDataValidation; if (!(dataValidation is XLDataValidation) || @@ -166,7 +183,7 @@ internal IXLDataValidation Add(IXLDataValidation dataValidation, bool skipInters public void Consolidate() { - Func areEqual = (dv1, dv2) => + bool areEqual(IXLDataValidation dv1, IXLDataValidation dv2) { return dv1.IgnoreBlanks == dv2.IgnoreBlanks && @@ -183,7 +200,7 @@ public void Consolidate() dv1.MinValue == dv2.MinValue && dv1.MaxValue == dv2.MaxValue && dv1.Value == dv2.Value; - }; + } var rules = _dataValidations.ToList(); rules.ForEach(Delete); @@ -240,7 +257,10 @@ private void ProcessRangeRemoved(IXLRange range) private void SplitExistingRanges(IXLRangeAddress rangeAddress) { - if (_skipSplittingExistingRanges) return; + if (_skipSplittingExistingRanges) + { + return; + } try { diff --git a/ClosedXML/Excel/DataValidation/XLDecimalCriteria.cs b/ClosedXML/Excel/DataValidation/XLDecimalCriteria.cs index f8ac16fa5..4674b4cbc 100644 --- a/ClosedXML/Excel/DataValidation/XLDecimalCriteria.cs +++ b/ClosedXML/Excel/DataValidation/XLDecimalCriteria.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -10,20 +9,20 @@ public XLDecimalCriteria(IXLDataValidation dataValidation) { } - public void Between(Double minValue, Double maxValue) => base.Between(minValue.ToInvariantString(), maxValue.ToInvariantString()); + public void Between(double minValue, double maxValue) => Between(minValue.ToInvariantString(), maxValue.ToInvariantString()); - public void EqualOrGreaterThan(Double value) => base.EqualOrGreaterThan(value.ToInvariantString()); + public void EqualOrGreaterThan(double value) => EqualOrGreaterThan(value.ToInvariantString()); - public void EqualOrLessThan(Double value) => base.EqualOrLessThan(value.ToInvariantString()); + public void EqualOrLessThan(double value) => EqualOrLessThan(value.ToInvariantString()); - public void EqualTo(Double value) => base.EqualTo(value.ToInvariantString()); + public void EqualTo(double value) => EqualTo(value.ToInvariantString()); - public void GreaterThan(Double value) => base.GreaterThan(value.ToInvariantString()); + public void GreaterThan(double value) => GreaterThan(value.ToInvariantString()); - public void LessThan(Double value) => base.LessThan(value.ToInvariantString()); + public void LessThan(double value) => LessThan(value.ToInvariantString()); - public void NotBetween(Double minValue, Double maxValue) => base.NotBetween(minValue.ToInvariantString(), maxValue.ToInvariantString()); + public void NotBetween(double minValue, double maxValue) => NotBetween(minValue.ToInvariantString(), maxValue.ToInvariantString()); - public void NotEqualTo(Double value) => base.NotEqualTo(value.ToInvariantString()); + public void NotEqualTo(double value) => NotEqualTo(value.ToInvariantString()); } } diff --git a/ClosedXML/Excel/DataValidation/XLTimeCriteria.cs b/ClosedXML/Excel/DataValidation/XLTimeCriteria.cs index 46031106f..87e8b9f12 100644 --- a/ClosedXML/Excel/DataValidation/XLTimeCriteria.cs +++ b/ClosedXML/Excel/DataValidation/XLTimeCriteria.cs @@ -10,23 +10,23 @@ public XLTimeCriteria(IXLDataValidation dataValidation) { } - public void Between(TimeSpan minValue, TimeSpan maxValue) => base.Between(GetXLTime(minValue), GetXLTime(maxValue)); + public void Between(TimeSpan minValue, TimeSpan maxValue) => Between(GetXLTime(minValue), GetXLTime(maxValue)); - public void EqualOrGreaterThan(TimeSpan value) => base.EqualOrGreaterThan(GetXLTime(value)); + public void EqualOrGreaterThan(TimeSpan value) => EqualOrGreaterThan(GetXLTime(value)); - public void EqualOrLessThan(TimeSpan value) => base.EqualOrLessThan(GetXLTime(value)); + public void EqualOrLessThan(TimeSpan value) => EqualOrLessThan(GetXLTime(value)); - public void EqualTo(TimeSpan value) => base.EqualTo(GetXLTime(value)); + public void EqualTo(TimeSpan value) => EqualTo(GetXLTime(value)); - public void GreaterThan(TimeSpan value) => base.GreaterThan(GetXLTime(value)); + public void GreaterThan(TimeSpan value) => GreaterThan(GetXLTime(value)); - public void LessThan(TimeSpan value) => base.LessThan(GetXLTime(value)); + public void LessThan(TimeSpan value) => LessThan(GetXLTime(value)); - public void NotBetween(TimeSpan minValue, TimeSpan maxValue) => base.NotBetween(GetXLTime(minValue), GetXLTime(maxValue)); + public void NotBetween(TimeSpan minValue, TimeSpan maxValue) => NotBetween(GetXLTime(minValue), GetXLTime(maxValue)); - public void NotEqualTo(TimeSpan value) => base.NotEqualTo(GetXLTime(value)); + public void NotEqualTo(TimeSpan value) => NotEqualTo(GetXLTime(value)); - private static String GetXLTime(TimeSpan value) + private static string GetXLTime(TimeSpan value) { return (value.TotalHours / 24.0).ToString(); } diff --git a/ClosedXML/Excel/DataValidation/XLValidationCriteria.cs b/ClosedXML/Excel/DataValidation/XLValidationCriteria.cs index a18af3153..4206d0952 100644 --- a/ClosedXML/Excel/DataValidation/XLValidationCriteria.cs +++ b/ClosedXML/Excel/DataValidation/XLValidationCriteria.cs @@ -14,7 +14,7 @@ protected XLValidationCriteria(IXLDataValidation dataValidation) #region IXLValidationCriteria Members - public void Between(String minValue, String maxValue) + public void Between(string minValue, string maxValue) { dataValidation.MinValue = minValue; dataValidation.MaxValue = maxValue; @@ -36,7 +36,7 @@ public void Between(IXLCell minValue, IXLCell maxValue) dataValidation.Operator = XLOperator.Between; } - public void EqualOrGreaterThan(String value) + public void EqualOrGreaterThan(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.EqualOrGreaterThan; @@ -55,7 +55,7 @@ public void EqualOrGreaterThan(IXLCell cell) dataValidation.Operator = XLOperator.EqualOrGreaterThan; } - public void EqualOrLessThan(String value) + public void EqualOrLessThan(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.EqualOrLessThan; @@ -74,7 +74,7 @@ public void EqualOrLessThan(IXLCell cell) dataValidation.Operator = XLOperator.EqualOrLessThan; } - public void EqualTo(String value) + public void EqualTo(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.EqualTo; @@ -93,7 +93,7 @@ public void EqualTo(IXLCell cell) dataValidation.Operator = XLOperator.EqualTo; } - public void GreaterThan(String value) + public void GreaterThan(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.GreaterThan; @@ -112,7 +112,7 @@ public void GreaterThan(IXLCell cell) dataValidation.Operator = XLOperator.GreaterThan; } - public void LessThan(String value) + public void LessThan(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.LessThan; @@ -131,7 +131,7 @@ public void LessThan(IXLCell cell) dataValidation.Operator = XLOperator.LessThan; } - public void NotBetween(String minValue, String maxValue) + public void NotBetween(string minValue, string maxValue) { dataValidation.MinValue = minValue; dataValidation.MaxValue = maxValue; @@ -153,7 +153,7 @@ public void NotBetween(IXLCell minValue, IXLCell maxValue) dataValidation.Operator = XLOperator.NotBetween; } - public void NotEqualTo(String value) + public void NotEqualTo(string value) { dataValidation.Value = value; dataValidation.Operator = XLOperator.NotEqualTo; diff --git a/ClosedXML/Excel/DataValidation/XLWholeNumberCriteriaBase.cs b/ClosedXML/Excel/DataValidation/XLWholeNumberCriteriaBase.cs index 1fa3458a4..eda5d1708 100644 --- a/ClosedXML/Excel/DataValidation/XLWholeNumberCriteriaBase.cs +++ b/ClosedXML/Excel/DataValidation/XLWholeNumberCriteriaBase.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -10,20 +9,20 @@ protected XLWholeNumberCriteriaBase(IXLDataValidation dataValidation) { } - public void Between(Int32 minValue, Int32 maxValue) => base.Between(minValue.ToInvariantString(), maxValue.ToInvariantString()); + public void Between(int minValue, int maxValue) => Between(minValue.ToInvariantString(), maxValue.ToInvariantString()); - public void EqualOrGreaterThan(Int32 value) => base.EqualOrGreaterThan(value.ToInvariantString()); + public void EqualOrGreaterThan(int value) => EqualOrGreaterThan(value.ToInvariantString()); - public void EqualOrLessThan(Int32 value) => base.EqualOrLessThan(value.ToInvariantString()); + public void EqualOrLessThan(int value) => EqualOrLessThan(value.ToInvariantString()); - public void EqualTo(Int32 value) => base.EqualTo(value.ToInvariantString()); + public void EqualTo(int value) => EqualTo(value.ToInvariantString()); - public void GreaterThan(Int32 value) => base.GreaterThan(value.ToInvariantString()); + public void GreaterThan(int value) => GreaterThan(value.ToInvariantString()); - public void LessThan(Int32 value) => base.LessThan(value.ToInvariantString()); + public void LessThan(int value) => LessThan(value.ToInvariantString()); - public void NotBetween(Int32 minValue, Int32 maxValue) => base.NotBetween(minValue.ToInvariantString(), maxValue.ToInvariantString()); + public void NotBetween(int minValue, int maxValue) => NotBetween(minValue.ToInvariantString(), maxValue.ToInvariantString()); - public void NotEqualTo(Int32 value) => base.NotEqualTo(value.ToInvariantString()); + public void NotEqualTo(int value) => NotEqualTo(value.ToInvariantString()); } } diff --git a/ClosedXML/Excel/Drawings/IXLDrawing.cs b/ClosedXML/Excel/Drawings/IXLDrawing.cs index c00631532..bd29f2479 100644 --- a/ClosedXML/Excel/Drawings/IXLDrawing.cs +++ b/ClosedXML/Excel/Drawings/IXLDrawing.cs @@ -1,15 +1,13 @@ -using System; - namespace ClosedXML.Excel { public enum XLDrawingAnchor { MoveAndSizeWithCells, MoveWithCells, Absolute} public interface IXLDrawing { - Int32 ShapeId { get; } + int ShapeId { get; } - Boolean Visible { get; set; } + bool Visible { get; set; } T SetVisible(); - T SetVisible(Boolean hidden); + T SetVisible(bool hidden); ////String Name { get; set; } ////T SetName(String name); @@ -19,8 +17,8 @@ public interface IXLDrawing IXLDrawingPosition Position { get; } - Int32 ZOrder { get; set; } - T SetZOrder(Int32 zOrder); + int ZOrder { get; set; } + T SetZOrder(int zOrder); //Boolean HorizontalFlip { get; set; } //T SetHorizontalFlip(); diff --git a/ClosedXML/Excel/Drawings/IXLDrawingPosition.cs b/ClosedXML/Excel/Drawings/IXLDrawingPosition.cs index 2b3322918..9358dc7db 100644 --- a/ClosedXML/Excel/Drawings/IXLDrawingPosition.cs +++ b/ClosedXML/Excel/Drawings/IXLDrawingPosition.cs @@ -1,20 +1,15 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingPosition { - Int32 Column { get; set; } - IXLDrawingPosition SetColumn(Int32 column); - Double ColumnOffset { get; set; } - IXLDrawingPosition SetColumnOffset(Double columnOffset); + int Column { get; set; } + IXLDrawingPosition SetColumn(int column); + double ColumnOffset { get; set; } + IXLDrawingPosition SetColumnOffset(double columnOffset); - Int32 Row { get; set; } - IXLDrawingPosition SetRow(Int32 row); - Double RowOffset { get; set; } - IXLDrawingPosition SetRowOffset(Double rowOffset); + int Row { get; set; } + IXLDrawingPosition SetRow(int row); + double RowOffset { get; set; } + IXLDrawingPosition SetRowOffset(double rowOffset); } } diff --git a/ClosedXML/Excel/Drawings/IXLPicture.cs b/ClosedXML/Excel/Drawings/IXLPicture.cs index 20364704a..f14404de0 100644 --- a/ClosedXML/Excel/Drawings/IXLPicture.cs +++ b/ClosedXML/Excel/Drawings/IXLPicture.cs @@ -1,6 +1,7 @@ // Keep this file CodeMaid organised and cleaned +using SkiaSharp; using System; -using System.Drawing; + using System.IO; namespace ClosedXML.Excel.Drawings @@ -15,27 +16,27 @@ public interface IXLPicture : IDisposable /// XLPictureFormat Format { get; } - Int32 Height { get; set; } + int Height { get; set; } - Int32 Id { get; } + int Id { get; } MemoryStream ImageStream { get; } - Int32 Left { get; set; } + float Left { get; set; } - String Name { get; set; } + string Name { get; set; } - Int32 OriginalHeight { get; } + int OriginalHeight { get; } - Int32 OriginalWidth { get; } + int OriginalWidth { get; } XLPicturePlacement Placement { get; set; } - Int32 Top { get; set; } + float Top { get; set; } IXLCell TopLeftCell { get; } - Int32 Width { get; set; } + int Width { get; set; } IXLWorksheet Worksheet { get; } @@ -57,30 +58,30 @@ public interface IXLPicture : IDisposable /// A created copy of the picture. IXLPicture Duplicate(); - Point GetOffset(XLMarkerPosition position); + SKPoint GetOffset(XLMarkerPosition position); - IXLPicture MoveTo(Int32 left, Int32 top); + IXLPicture MoveTo(float left, float top); IXLPicture MoveTo(IXLCell cell); - IXLPicture MoveTo(IXLCell cell, Int32 xOffset, Int32 yOffset); + IXLPicture MoveTo(IXLCell cell, int xOffset, int yOffset); - IXLPicture MoveTo(IXLCell cell, Point offset); + IXLPicture MoveTo(IXLCell cell, SKPoint offset); IXLPicture MoveTo(IXLCell fromCell, IXLCell toCell); - IXLPicture MoveTo(IXLCell fromCell, Int32 fromCellXOffset, Int32 fromCellYOffset, IXLCell toCell, Int32 toCellXOffset, Int32 toCellYOffset); + IXLPicture MoveTo(IXLCell fromCell, int fromCellXOffset, int fromCellYOffset, IXLCell toCell, int toCellXOffset, int toCellYOffset); - IXLPicture MoveTo(IXLCell fromCell, Point fromOffset, IXLCell toCell, Point toOffset); + IXLPicture MoveTo(IXLCell fromCell, SKPoint fromOffset, IXLCell toCell, SKPoint toOffset); - IXLPicture Scale(Double factor, Boolean relativeToOriginal = false); + IXLPicture Scale(double factor, bool relativeToOriginal = false); - IXLPicture ScaleHeight(Double factor, Boolean relativeToOriginal = false); + IXLPicture ScaleHeight(double factor, bool relativeToOriginal = false); - IXLPicture ScaleWidth(Double factor, Boolean relativeToOriginal = false); + IXLPicture ScaleWidth(double factor, bool relativeToOriginal = false); IXLPicture WithPlacement(XLPicturePlacement value); - IXLPicture WithSize(Int32 width, Int32 height); + IXLPicture WithSize(int width, int height); } } diff --git a/ClosedXML/Excel/Drawings/IXLPictures.cs b/ClosedXML/Excel/Drawings/IXLPictures.cs index 34ed7823f..b9cd97922 100644 --- a/ClosedXML/Excel/Drawings/IXLPictures.cs +++ b/ClosedXML/Excel/Drawings/IXLPictures.cs @@ -1,6 +1,5 @@ -using System; +using SkiaSharp; using System.Collections.Generic; -using System.Drawing; using System.IO; namespace ClosedXML.Excel.Drawings @@ -11,28 +10,28 @@ public interface IXLPictures : IEnumerable IXLPicture Add(Stream stream); - IXLPicture Add(Stream stream, String name); + IXLPicture Add(Stream stream, string name); IXLPicture Add(Stream stream, XLPictureFormat format); - IXLPicture Add(Stream stream, XLPictureFormat format, String name); + IXLPicture Add(Stream stream, XLPictureFormat format, string name); - IXLPicture Add(Bitmap bitmap); + IXLPicture Add(SKCodec bitmap); - IXLPicture Add(Bitmap bitmap, String name); + IXLPicture Add(SKCodec bitmap, string name); - IXLPicture Add(String imageFile); + IXLPicture Add(string imageFile); - IXLPicture Add(String imageFile, String name); + IXLPicture Add(string imageFile, string name); - bool Contains(String pictureName); + bool Contains(string pictureName); - void Delete(String pictureName); + void Delete(string pictureName); void Delete(IXLPicture picture); - IXLPicture Picture(String pictureName); + IXLPicture Picture(string pictureName); - bool TryGetPicture(String pictureName, out IXLPicture picture); + bool TryGetPicture(string pictureName, out IXLPicture picture); } } diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingAlignment.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingAlignment.cs index eb68bbb2f..7ecaf1252 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingAlignment.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingAlignment.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public enum XLDrawingTextDirection @@ -24,13 +19,13 @@ public interface IXLDrawingAlignment { XLDrawingHorizontalAlignment Horizontal { get; set; } XLDrawingVerticalAlignment Vertical { get; set; } - Boolean AutomaticSize { get; set; } + bool AutomaticSize { get; set; } XLDrawingTextDirection Direction { get; set; } XLDrawingTextOrientation Orientation { get; set; } IXLDrawingStyle SetHorizontal(XLDrawingHorizontalAlignment value); IXLDrawingStyle SetVertical(XLDrawingVerticalAlignment value); - IXLDrawingStyle SetAutomaticSize(); IXLDrawingStyle SetAutomaticSize(Boolean value); + IXLDrawingStyle SetAutomaticSize(); IXLDrawingStyle SetAutomaticSize(bool value); IXLDrawingStyle SetDirection(XLDrawingTextDirection value); IXLDrawingStyle SetOrientation(XLDrawingTextOrientation value); diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingColorsAndLines.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingColorsAndLines.cs index 72a6fec3b..4e40c4a26 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingColorsAndLines.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingColorsAndLines.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public enum XLDashStyle @@ -16,27 +11,34 @@ public enum XLDashStyle LongDashDot, LongDashDotDot } + public enum XLLineStyle { Single, ThinThin, ThinThick, ThickThin, ThickBetweenThin } + public interface IXLDrawingColorsAndLines { XLColor FillColor { get; set; } - Double FillTransparency { get; set; } + double FillTransparency { get; set; } XLColor LineColor { get; set; } - Double LineTransparency { get; set; } - Double LineWeight { get; set; } + double LineTransparency { get; set; } + double LineWeight { get; set; } XLDashStyle LineDash { get; set; } XLLineStyle LineStyle { get; set; } IXLDrawingStyle SetFillColor(XLColor value); - IXLDrawingStyle SetFillTransparency(Double value); + + IXLDrawingStyle SetFillTransparency(double value); + IXLDrawingStyle SetLineColor(XLColor value); - IXLDrawingStyle SetLineTransparency(Double value); - IXLDrawingStyle SetLineWeight(Double value); + + IXLDrawingStyle SetLineTransparency(double value); + + IXLDrawingStyle SetLineWeight(double value); + IXLDrawingStyle SetLineDash(XLDashStyle value); - IXLDrawingStyle SetLineStyle(XLLineStyle value); + IXLDrawingStyle SetLineStyle(XLLineStyle value); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingFont.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingFont.cs index 878f23b3c..584a43df3 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingFont.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingFont.cs @@ -1,21 +1,16 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingFont : IXLFontBase { - IXLDrawingStyle SetBold(); IXLDrawingStyle SetBold(Boolean value); - IXLDrawingStyle SetItalic(); IXLDrawingStyle SetItalic(Boolean value); + IXLDrawingStyle SetBold(); IXLDrawingStyle SetBold(bool value); + IXLDrawingStyle SetItalic(); IXLDrawingStyle SetItalic(bool value); IXLDrawingStyle SetUnderline(); IXLDrawingStyle SetUnderline(XLFontUnderlineValues value); - IXLDrawingStyle SetStrikethrough(); IXLDrawingStyle SetStrikethrough(Boolean value); + IXLDrawingStyle SetStrikethrough(); IXLDrawingStyle SetStrikethrough(bool value); IXLDrawingStyle SetVerticalAlignment(XLFontVerticalTextAlignmentValues value); - IXLDrawingStyle SetShadow(); IXLDrawingStyle SetShadow(Boolean value); - IXLDrawingStyle SetFontSize(Double value); + IXLDrawingStyle SetShadow(); IXLDrawingStyle SetShadow(bool value); + IXLDrawingStyle SetFontSize(double value); IXLDrawingStyle SetFontColor(XLColor value); - IXLDrawingStyle SetFontName(String value); + IXLDrawingStyle SetFontName(string value); IXLDrawingStyle SetFontFamilyNumbering(XLFontFamilyNumberingValues value); IXLDrawingStyle SetFontCharSet(XLFontCharSet value); } diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingMargins.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingMargins.cs index 759cd44c3..a345c5689 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingMargins.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingMargins.cs @@ -1,25 +1,20 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingMargins { - Boolean Automatic { get; set; } - Double Left { get; set; } - Double Right { get; set; } - Double Top { get; set; } - Double Bottom { get; set; } - Double All { set; } + bool Automatic { get; set; } + double Left { get; set; } + double Right { get; set; } + double Top { get; set; } + double Bottom { get; set; } + double All { set; } - IXLDrawingStyle SetAutomatic(); IXLDrawingStyle SetAutomatic(Boolean value); - IXLDrawingStyle SetLeft(Double value); - IXLDrawingStyle SetRight(Double value); - IXLDrawingStyle SetTop(Double value); - IXLDrawingStyle SetBottom(Double value); - IXLDrawingStyle SetAll(Double value); + IXLDrawingStyle SetAutomatic(); IXLDrawingStyle SetAutomatic(bool value); + IXLDrawingStyle SetLeft(double value); + IXLDrawingStyle SetRight(double value); + IXLDrawingStyle SetTop(double value); + IXLDrawingStyle SetBottom(double value); + IXLDrawingStyle SetAll(double value); } } diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingProperties.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingProperties.cs index 615794646..1347bb1e7 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingProperties.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingProperties.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingProperties diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingProtection.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingProtection.cs index 36f896b6a..37e966471 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingProtection.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingProtection.cs @@ -1,17 +1,12 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingProtection { - Boolean Locked { get; set; } - Boolean LockText { get; set; } + bool Locked { get; set; } + bool LockText { get; set; } - IXLDrawingStyle SetLocked(); IXLDrawingStyle SetLocked(Boolean value); - IXLDrawingStyle SetLockText(); IXLDrawingStyle SetLockText(Boolean value); + IXLDrawingStyle SetLocked(); IXLDrawingStyle SetLocked(bool value); + IXLDrawingStyle SetLockText(); IXLDrawingStyle SetLockText(bool value); } } diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingSize.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingSize.cs index 5b83d320c..330458744 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingSize.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingSize.cs @@ -1,19 +1,14 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingSize { - Boolean AutomaticSize { get; set; } - Double Height { get; set; } - Double Width { get; set; } + bool AutomaticSize { get; set; } + double Height { get; set; } + double Width { get; set; } - IXLDrawingStyle SetAutomaticSize(); IXLDrawingStyle SetAutomaticSize(Boolean value); - IXLDrawingStyle SetHeight(Double value); - IXLDrawingStyle SetWidth(Double value); + IXLDrawingStyle SetAutomaticSize(); IXLDrawingStyle SetAutomaticSize(bool value); + IXLDrawingStyle SetHeight(double value); + IXLDrawingStyle SetWidth(double value); } } diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingStyle.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingStyle.cs index 9eed6a8de..2c265f897 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingStyle.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingStyle.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingStyle diff --git a/ClosedXML/Excel/Drawings/Style/IXLDrawingWeb.cs b/ClosedXML/Excel/Drawings/Style/IXLDrawingWeb.cs index 00324881a..eceb7d676 100644 --- a/ClosedXML/Excel/Drawings/Style/IXLDrawingWeb.cs +++ b/ClosedXML/Excel/Drawings/Style/IXLDrawingWeb.cs @@ -1,14 +1,9 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLDrawingWeb { - String AlternateText { get; set; } - IXLDrawingStyle SetAlternateText(String value); + string AlternateText { get; set; } + IXLDrawingStyle SetAlternateText(string value); } } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingAlignment.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingAlignment.cs index 3da9f89fa..8e0d3b6e5 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingAlignment.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingAlignment.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingAlignment: IXLDrawingAlignment @@ -15,7 +10,7 @@ public XLDrawingAlignment(IXLDrawingStyle style) } public XLDrawingHorizontalAlignment Horizontal { get; set; } public IXLDrawingStyle SetHorizontal(XLDrawingHorizontalAlignment value) { Horizontal = value; return _style; } public XLDrawingVerticalAlignment Vertical { get; set; } public IXLDrawingStyle SetVertical(XLDrawingVerticalAlignment value) { Vertical = value; return _style; } - public Boolean AutomaticSize { get; set; } public IXLDrawingStyle SetAutomaticSize() { AutomaticSize = true; return _style; } public IXLDrawingStyle SetAutomaticSize(Boolean value) { AutomaticSize = value; return _style; } + public bool AutomaticSize { get; set; } public IXLDrawingStyle SetAutomaticSize() { AutomaticSize = true; return _style; } public IXLDrawingStyle SetAutomaticSize(bool value) { AutomaticSize = value; return _style; } public XLDrawingTextDirection Direction { get; set; } public IXLDrawingStyle SetDirection(XLDrawingTextDirection value) { Direction = value; return _style; } public XLDrawingTextOrientation Orientation { get; set; } public IXLDrawingStyle SetOrientation(XLDrawingTextOrientation value) { Orientation = value; return _style; } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingColorsAndLines.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingColorsAndLines.cs index ec8e4dbe7..b8d7a8d12 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingColorsAndLines.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingColorsAndLines.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingColorsAndLines: IXLDrawingColorsAndLines @@ -14,10 +9,10 @@ public XLDrawingColorsAndLines(IXLDrawingStyle style) _style = style; } public XLColor FillColor { get; set; } public IXLDrawingStyle SetFillColor(XLColor value) { FillColor = value; return _style; } - public Double FillTransparency { get; set; } public IXLDrawingStyle SetFillTransparency(Double value) { FillTransparency = value; return _style; } + public double FillTransparency { get; set; } public IXLDrawingStyle SetFillTransparency(double value) { FillTransparency = value; return _style; } public XLColor LineColor { get; set; } public IXLDrawingStyle SetLineColor(XLColor value) { LineColor = value; return _style; } - public Double LineTransparency { get; set; } public IXLDrawingStyle SetLineTransparency(Double value) { LineTransparency = value; return _style; } - public Double LineWeight { get; set; } public IXLDrawingStyle SetLineWeight(Double value) { LineWeight = value; return _style; } + public double LineTransparency { get; set; } public IXLDrawingStyle SetLineTransparency(double value) { LineTransparency = value; return _style; } + public double LineWeight { get; set; } public IXLDrawingStyle SetLineWeight(double value) { LineWeight = value; return _style; } public XLDashStyle LineDash { get; set; } public IXLDrawingStyle SetLineDash(XLDashStyle value) { LineDash = value; return _style; } public XLLineStyle LineStyle { get; set; } public IXLDrawingStyle SetLineStyle(XLLineStyle value) { LineStyle = value; return _style; } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingFont.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingFont.cs index 744d7817d..2c153e3e8 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingFont.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingFont.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLDrawingFont : IXLDrawingFont @@ -15,15 +13,15 @@ public XLDrawingFont(IXLDrawingStyle style) FontColor = XLColor.FromIndex(64); } - public Boolean Bold { get; set; } - public Boolean Italic { get; set; } + public bool Bold { get; set; } + public bool Italic { get; set; } public XLFontUnderlineValues Underline { get; set; } - public Boolean Strikethrough { get; set; } + public bool Strikethrough { get; set; } public XLFontVerticalTextAlignmentValues VerticalAlignment { get; set; } - public Boolean Shadow { get; set; } - public Double FontSize { get; set; } + public bool Shadow { get; set; } + public double FontSize { get; set; } public XLColor FontColor { get; set; } - public String FontName { get; set; } + public string FontName { get; set; } public XLFontFamilyNumberingValues FontFamilyNumbering { get; set; } public XLFontCharSet FontCharSet { get; set; } @@ -34,7 +32,7 @@ public IXLDrawingStyle SetBold() return _style; } - public IXLDrawingStyle SetBold(Boolean value) + public IXLDrawingStyle SetBold(bool value) { Bold = value; return _style; @@ -46,7 +44,7 @@ public IXLDrawingStyle SetItalic() return _style; } - public IXLDrawingStyle SetItalic(Boolean value) + public IXLDrawingStyle SetItalic(bool value) { Italic = value; return _style; @@ -70,7 +68,7 @@ public IXLDrawingStyle SetStrikethrough() return _style; } - public IXLDrawingStyle SetStrikethrough(Boolean value) + public IXLDrawingStyle SetStrikethrough(bool value) { Strikethrough = value; return _style; @@ -88,13 +86,13 @@ public IXLDrawingStyle SetShadow() return _style; } - public IXLDrawingStyle SetShadow(Boolean value) + public IXLDrawingStyle SetShadow(bool value) { Shadow = value; return _style; } - public IXLDrawingStyle SetFontSize(Double value) + public IXLDrawingStyle SetFontSize(double value) { FontSize = value; return _style; @@ -106,7 +104,7 @@ public IXLDrawingStyle SetFontColor(XLColor value) return _style; } - public IXLDrawingStyle SetFontName(String value) + public IXLDrawingStyle SetFontName(string value) { FontName = value; return _style; diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingMargins.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingMargins.cs index 650f7a13c..40365a87d 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingMargins.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingMargins.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingMargins: IXLDrawingMargins @@ -12,17 +7,17 @@ public XLDrawingMargins(IXLDrawingStyle style) { _style = style; } - public Boolean Automatic { get; set; } public IXLDrawingStyle SetAutomatic() { Automatic = true; return _style; } public IXLDrawingStyle SetAutomatic(Boolean value) { Automatic = value; return _style; } - Double _left; - public Double Left { get { return _left; } set { _left = value; Automatic = false; } } - public IXLDrawingStyle SetLeft(Double value) { Left = value; return _style; } - Double _right; - public Double Right { get { return _right; } set { _right = value; Automatic = false; } } public IXLDrawingStyle SetRight(Double value) { Right = value; return _style; } - Double _top; - public Double Top { get { return _top; } set { _top = value; Automatic = false; } } public IXLDrawingStyle SetTop(Double value) { Top = value; return _style; } - Double _bottom; - public Double Bottom { get { return _bottom; } set { _bottom = value; Automatic = false; } } public IXLDrawingStyle SetBottom(Double value) { Bottom = value; return _style; } - public Double All + public bool Automatic { get; set; } public IXLDrawingStyle SetAutomatic() { Automatic = true; return _style; } public IXLDrawingStyle SetAutomatic(bool value) { Automatic = value; return _style; } + double _left; + public double Left { get { return _left; } set { _left = value; Automatic = false; } } + public IXLDrawingStyle SetLeft(double value) { Left = value; return _style; } + double _right; + public double Right { get { return _right; } set { _right = value; Automatic = false; } } public IXLDrawingStyle SetRight(double value) { Right = value; return _style; } + double _top; + public double Top { get { return _top; } set { _top = value; Automatic = false; } } public IXLDrawingStyle SetTop(double value) { Top = value; return _style; } + double _bottom; + public double Bottom { get { return _bottom; } set { _bottom = value; Automatic = false; } } public IXLDrawingStyle SetBottom(double value) { Bottom = value; return _style; } + public double All { set { @@ -33,6 +28,6 @@ public Double All Automatic = false; } } - public IXLDrawingStyle SetAll(Double value) { All = value; return _style; } + public IXLDrawingStyle SetAll(double value) { All = value; return _style; } } } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingProperties.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingProperties.cs index a70276206..e798d7363 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingProperties.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingProperties.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingProperties : IXLDrawingProperties diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingProtection.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingProtection.cs index 8d0c57042..0ce2d5209 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingProtection.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingProtection.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingProtection : IXLDrawingProtection @@ -13,8 +8,8 @@ public XLDrawingProtection(IXLDrawingStyle style) { _style = style; } - public Boolean Locked { get; set; } public IXLDrawingStyle SetLocked() { Locked = true; return _style; } public IXLDrawingStyle SetLocked(Boolean value) { Locked = value; return _style; } - public Boolean LockText { get; set; } public IXLDrawingStyle SetLockText() { LockText = true; return _style; } public IXLDrawingStyle SetLockText(Boolean value) { LockText = value; return _style; } + public bool Locked { get; set; } public IXLDrawingStyle SetLocked() { Locked = true; return _style; } public IXLDrawingStyle SetLocked(bool value) { Locked = value; return _style; } + public bool LockText { get; set; } public IXLDrawingStyle SetLockText() { LockText = true; return _style; } public IXLDrawingStyle SetLockText(bool value) { LockText = value; return _style; } } } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingSize.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingSize.cs index 84f4f1b1d..4111bb088 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingSize.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingSize.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingSize : IXLDrawingSize @@ -14,9 +9,9 @@ public XLDrawingSize(IXLDrawingStyle style) _style = style; } - public Boolean AutomaticSize { get { return _style.Alignment.AutomaticSize; } set { _style.Alignment.AutomaticSize = value; } } - public IXLDrawingStyle SetAutomaticSize() { AutomaticSize = true; return _style; } public IXLDrawingStyle SetAutomaticSize(Boolean value) { AutomaticSize = value; return _style; } - public Double Height { get; set; } public IXLDrawingStyle SetHeight(Double value) { Height = value; return _style; } - public Double Width { get; set; } public IXLDrawingStyle SetWidth(Double value) { Width = value; return _style; } + public bool AutomaticSize { get { return _style.Alignment.AutomaticSize; } set { _style.Alignment.AutomaticSize = value; } } + public IXLDrawingStyle SetAutomaticSize() { AutomaticSize = true; return _style; } public IXLDrawingStyle SetAutomaticSize(bool value) { AutomaticSize = value; return _style; } + public double Height { get; set; } public IXLDrawingStyle SetHeight(double value) { Height = value; return _style; } + public double Width { get; set; } public IXLDrawingStyle SetWidth(double value) { Width = value; return _style; } } } diff --git a/ClosedXML/Excel/Drawings/Style/XLDrawingWeb.cs b/ClosedXML/Excel/Drawings/Style/XLDrawingWeb.cs index f47cb3bc8..c0528ae72 100644 --- a/ClosedXML/Excel/Drawings/Style/XLDrawingWeb.cs +++ b/ClosedXML/Excel/Drawings/Style/XLDrawingWeb.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingWeb : IXLDrawingWeb @@ -13,7 +8,7 @@ public XLDrawingWeb(IXLDrawingStyle style) { _style = style; } - public String AlternateText { get; set; } public IXLDrawingStyle SetAlternateText(String value) { AlternateText = value; return _style; } + public string AlternateText { get; set; } public IXLDrawingStyle SetAlternateText(string value) { AlternateText = value; return _style; } } } diff --git a/ClosedXML/Excel/Drawings/XLDrawing.cs b/ClosedXML/Excel/Drawings/XLDrawing.cs index c3e3a83d0..fceb9d554 100644 --- a/ClosedXML/Excel/Drawings/XLDrawing.cs +++ b/ClosedXML/Excel/Drawings/XLDrawing.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLDrawing: IXLDrawing @@ -11,29 +9,29 @@ public XLDrawing() Position = new XLDrawingPosition(); } - public Int32 ShapeId { get; internal set; } + public int ShapeId { get; internal set; } - public Boolean Visible { get; set; } + public bool Visible { get; set; } public T SetVisible() { Visible = true; return Container; } - public T SetVisible(Boolean hidden) + public T SetVisible(bool hidden) { Visible = hidden; return Container; } - public String Name { get; set; } - public T SetName(String name) + public string Name { get; set; } + public T SetName(string name) { Name = name; return Container; } - public String Description { get; set; } - public T SetDescription(String description) + public string Description { get; set; } + public T SetDescription(string description) { Description = description; return Container; @@ -41,67 +39,67 @@ public T SetDescription(String description) public IXLDrawingPosition Position { get; private set; } - public Int32 ZOrder { get; set; } - public T SetZOrder(Int32 zOrder) + public int ZOrder { get; set; } + public T SetZOrder(int zOrder) { ZOrder = zOrder; return Container; } - public Boolean HorizontalFlip { get; set; } + public bool HorizontalFlip { get; set; } public T SetHorizontalFlip() { HorizontalFlip = true; return Container; } - public T SetHorizontalFlip(Boolean horizontalFlip) + public T SetHorizontalFlip(bool horizontalFlip) { HorizontalFlip = horizontalFlip; return Container; } - public Boolean VerticalFlip { get; set; } + public bool VerticalFlip { get; set; } public T SetVerticalFlip() { VerticalFlip = true; return Container; } - public T SetVerticalFlip(Boolean verticalFlip) + public T SetVerticalFlip(bool verticalFlip) { VerticalFlip = verticalFlip; return Container; } - public Int32 Rotation { get; set; } - public T SetRotation(Int32 rotation) + public int Rotation { get; set; } + public T SetRotation(int rotation) { Rotation = rotation; return Container; } - public Int32 OffsetX { get; set; } - public T SetOffsetX(Int32 offsetX) + public int OffsetX { get; set; } + public T SetOffsetX(int offsetX) { OffsetX = offsetX; return Container; } - public Int32 OffsetY { get; set; } - public T SetOffsetY(Int32 offsetY) + public int OffsetY { get; set; } + public T SetOffsetY(int offsetY) { OffsetY = offsetY; return Container; } - public Int32 ExtentLength { get; set; } - public T SetExtentLength(Int32 extentLength) + public int ExtentLength { get; set; } + public T SetExtentLength(int extentLength) { ExtentLength = extentLength; return Container; } - public Int32 ExtentWidth { get; set; } - public T SetExtentWidth(Int32 extentWidth) + public int ExtentWidth { get; set; } + public T SetExtentWidth(int extentWidth) { ExtentWidth = extentWidth; return Container; diff --git a/ClosedXML/Excel/Drawings/XLDrawingPosition.cs b/ClosedXML/Excel/Drawings/XLDrawingPosition.cs index b7309f288..3b8eb8870 100644 --- a/ClosedXML/Excel/Drawings/XLDrawingPosition.cs +++ b/ClosedXML/Excel/Drawings/XLDrawingPosition.cs @@ -1,20 +1,15 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLDrawingPosition: IXLDrawingPosition { - public Int32 Column { get; set; } - public IXLDrawingPosition SetColumn(Int32 column) { Column = column; return this; } - public Double ColumnOffset { get; set; } - public IXLDrawingPosition SetColumnOffset(Double columnOffset) { ColumnOffset = columnOffset; return this; } + public int Column { get; set; } + public IXLDrawingPosition SetColumn(int column) { Column = column; return this; } + public double ColumnOffset { get; set; } + public IXLDrawingPosition SetColumnOffset(double columnOffset) { ColumnOffset = columnOffset; return this; } - public Int32 Row { get; set; } - public IXLDrawingPosition SetRow(Int32 row) { Row = row; return this; } - public Double RowOffset { get; set; } - public IXLDrawingPosition SetRowOffset(Double rowOffset) { RowOffset = rowOffset; return this; } + public int Row { get; set; } + public IXLDrawingPosition SetRow(int row) { Row = row; return this; } + public double RowOffset { get; set; } + public IXLDrawingPosition SetRowOffset(double rowOffset) { RowOffset = rowOffset; return this; } } } diff --git a/ClosedXML/Excel/Drawings/XLMarker.cs b/ClosedXML/Excel/Drawings/XLMarker.cs index 57d496ab0..89cfb0dcb 100644 --- a/ClosedXML/Excel/Drawings/XLMarker.cs +++ b/ClosedXML/Excel/Drawings/XLMarker.cs @@ -1,7 +1,7 @@ // Keep this file CodeMaid organised and cleaned +using SkiaSharp; using System; using System.Diagnostics; -using System.Drawing; namespace ClosedXML.Excel.Drawings { @@ -13,25 +13,27 @@ internal class XLMarker private readonly IXLRange rangeCell; internal XLMarker(IXLCell cell) - : this(cell.AsRange(), new Point(0, 0)) + : this(cell.AsRange(), new SKPoint(0, 0)) { } - internal XLMarker(IXLCell cell, Point offset) + internal XLMarker(IXLCell cell, SKPoint offset) : this(cell.AsRange(), offset) { } - private XLMarker(IXLRange rangeCell, Point offset) + private XLMarker(IXLRange rangeCell, SKPoint offset) { if (rangeCell.RowCount() != 1 || rangeCell.ColumnCount() != 1) + { throw new ArgumentException("Range should contain only one cell.", nameof(rangeCell)); + } this.rangeCell = rangeCell; - this.Offset = offset; + Offset = offset; } - public IXLCell Cell { get => rangeCell.FirstCell(); } - public Int32 ColumnNumber { get => rangeCell.RangeAddress.FirstAddress.ColumnNumber; } - public Point Offset { get; set; } - public Int32 RowNumber { get => rangeCell.RangeAddress.FirstAddress.RowNumber; } + public IXLCell Cell => rangeCell.FirstCell(); + public int ColumnNumber => rangeCell.RangeAddress.FirstAddress.ColumnNumber; + public SKPoint Offset { get; set; } + public int RowNumber => rangeCell.RangeAddress.FirstAddress.RowNumber; } } diff --git a/ClosedXML/Excel/Drawings/XLPicture.cs b/ClosedXML/Excel/Drawings/XLPicture.cs index 816e2f00d..55308afb1 100644 --- a/ClosedXML/Excel/Drawings/XLPicture.cs +++ b/ClosedXML/Excel/Drawings/XLPicture.cs @@ -1,43 +1,65 @@ -// Keep this file CodeMaid organised and cleaned +using SkiaSharp; using System; using System.Collections.Generic; using System.Diagnostics; -using System.Drawing; -using System.Drawing.Imaging; using System.IO; using System.Linq; -using System.Reflection; namespace ClosedXML.Excel.Drawings { [DebuggerDisplay("{Name}")] internal class XLPicture : IXLPicture { - private const String InvalidNameChars = @":\/?*[]"; - private static readonly IDictionary _formatMap = BuildFormatMap(); - private Int32 _height; - private Int32 _id; - private String _name = string.Empty; - private Int32 _width; - - internal XLPicture(IXLWorksheet worksheet, Stream stream) - : this(worksheet) + private const string InvalidNameChars = @":\/?*[]"; + private const int ImageQuality = 70; + private static readonly IDictionary FormatMap; + + private bool _disposed; + + private int height; + private int id; + private string name = string.Empty; + private int width; + private readonly SKCodec codec; + + static XLPicture() + { + var SKEncodedImageFormatValues = Enum.GetValues(typeof(SKEncodedImageFormat)).OfType().ToList(); + + FormatMap = new Dictionary(); + + foreach (var xlpPiscutreFormat in Enum.GetValues(typeof(XLPictureFormat))) + { + var xlpPiscutreFormatName = xlpPiscutreFormat.ToString(); + var mathcingSKEncodedImageFormat = SKEncodedImageFormatValues.FirstOrDefault(value => value.ToString().Equals(xlpPiscutreFormatName, StringComparison.OrdinalIgnoreCase)); + FormatMap.Add((XLPictureFormat)xlpPiscutreFormat, mathcingSKEncodedImageFormat); + } + } + + internal XLPicture(IXLWorksheet worksheet, Stream stream) : this(worksheet) { - if (stream == null) throw new ArgumentNullException(nameof(stream)); + if (stream == null) { throw new ArgumentNullException(nameof(stream)); } - this.ImageStream = new MemoryStream(); + ImageStream = new MemoryStream(); { stream.Position = 0; stream.CopyTo(ImageStream); ImageStream.Seek(0, SeekOrigin.Begin); - using (var image = Image.FromStream(ImageStream)) + codec = SKCodec.Create(ImageStream, out var result); + + if (codec != null) { - if (_formatMap.Values.Select(f => f.Guid).Contains(image.RawFormat.Guid)) - this.Format = _formatMap.Single(f => f.Value.Guid.Equals(image.RawFormat.Guid)).Key; + using var bitmap = SKBitmap.Decode(codec); + if (FormatMap.Values.Contains(codec.EncodedFormat)) + { + Format = FormatMap.Single(f => f.Value.Equals(codec.EncodedFormat)).Key; + } - DeduceDimensionsFromBitmap(image); + DeduceDimensionsFromBitmap(bitmap); } + + stream.Position = 0; ImageStream.Seek(0, SeekOrigin.Begin); } } @@ -45,45 +67,67 @@ internal XLPicture(IXLWorksheet worksheet, Stream stream) internal XLPicture(IXLWorksheet worksheet, Stream stream, XLPictureFormat format) : this(worksheet) { - if (stream == null) throw new ArgumentNullException(nameof(stream)); - this.Format = format; + if (stream == null) + { + throw new ArgumentNullException(nameof(stream)); + } - this.ImageStream = new MemoryStream(); - stream.Position = 0; - stream.CopyTo(ImageStream); - ImageStream.Seek(0, SeekOrigin.Begin); + Format = format; - using (var image = Image.FromStream(ImageStream)) + ImageStream = new MemoryStream(); { - if (_formatMap.TryGetValue(this.Format, out ImageFormat imageFormat) && imageFormat.Guid != image.RawFormat.Guid) - throw new ArgumentException("The picture format in the stream and the parameter don't match"); + stream.Position = 0; + stream.CopyTo(ImageStream); + ImageStream.Seek(0, SeekOrigin.Begin); + + codec = SKCodec.Create(ImageStream, out var result); - DeduceDimensionsFromBitmap(image); + if (codec != null) + { + using var bitmap = SKBitmap.Decode(codec); + if (FormatMap.TryGetValue(Format, out var imageFormat) && imageFormat != codec.EncodedFormat) + { + throw new ArgumentException("The picture format in the stream and the parameter don't match"); + } + + DeduceDimensionsFromBitmap(bitmap); + } + + ImageStream.Seek(0, SeekOrigin.Begin); } - ImageStream.Seek(0, SeekOrigin.Begin); } - internal XLPicture(IXLWorksheet worksheet, Bitmap bitmap) - : this(worksheet) + internal XLPicture(IXLWorksheet worksheet, SKCodec codec) : this(worksheet) { - if (bitmap == null) throw new ArgumentNullException(nameof(bitmap)); - this.ImageStream = new MemoryStream(); - bitmap.Save(ImageStream, bitmap.RawFormat); - ImageStream.Seek(0, SeekOrigin.Begin); - DeduceDimensionsFromBitmap(bitmap); + if (codec == null) + { + throw new ArgumentNullException(nameof(codec)); + } + + ImageStream = new MemoryStream(); + + using (var bitmap = SKBitmap.Decode(codec)) + { + using var data = bitmap.Encode(codec.EncodedFormat, ImageQuality); + data.SaveTo(ImageStream); + ImageStream.Seek(0, SeekOrigin.Begin); + DeduceDimensionsFromBitmap(bitmap); + } - var formats = _formatMap.Where(f => f.Value.Guid.Equals(bitmap.RawFormat.Guid)); + var formats = FormatMap.Where(f => f.Value.Equals(codec.EncodedFormat)); if (!formats.Any() || formats.Count() > 1) - throw new ArgumentException("Unsupported or unknown image format in bitmap"); + { + throw new ArgumentException($"Unsupported or unknown image format '{codec.EncodedFormat}' in bitmap"); + } - this.Format = formats.Single().Key; + Format = formats.Single().Key; } private XLPicture(IXLWorksheet worksheet) { - this.Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); - this.Placement = XLPicturePlacement.MoveAndSize; - this.Markers = new Dictionary() + Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); + Placement = XLPicturePlacement.MoveAndSize; + Markers = new Dictionary() { [XLMarkerPosition.TopLeft] = null, [XLMarkerPosition.BottomRight] = null @@ -92,95 +136,154 @@ private XLPicture(IXLWorksheet worksheet) // Calculate default picture ID var allPictures = worksheet.Workbook.Worksheets.SelectMany(ws => ws.Pictures); if (allPictures.Any()) - this._id = allPictures.Max(p => p.Id) + 1; + { + id = allPictures.Max(p => p.Id) + 1; + } else - this._id = 1; + { + id = 1; + } } public IXLCell BottomRightCell { get { + ThrowIfDisposed(); + return Markers[XLMarkerPosition.BottomRight].Cell; } private set { - if (!value.Worksheet.Equals(this.Worksheet)) + ThrowIfDisposed(); + + if (!value.Worksheet.Equals(Worksheet)) + { throw new InvalidOperationException("A picture and its anchor cells must be on the same worksheet"); + } - this.Markers[XLMarkerPosition.BottomRight] = new XLMarker(value); + Markers[XLMarkerPosition.BottomRight] = new XLMarker(value); } } - public XLPictureFormat Format { get; private set; } = XLPictureFormat.Unknown; + public XLPictureFormat Format { get; private set; } - public Int32 Height + public int Height { - get { return _height; } + get + { + ThrowIfDisposed(); + + return height; + } set { - if (this.Placement == XLPicturePlacement.MoveAndSize) + ThrowIfDisposed(); + + if (Placement == XLPicturePlacement.MoveAndSize) + { throw new ArgumentException("To set the height, the placement should be FreeFloating or Move"); - _height = value; + } + + height = value; } } - public Int32 Id + public int Id { - get { return _id; } + get + { + ThrowIfDisposed(); + + return id; + } internal set { + ThrowIfDisposed(); + if ((Worksheet.Pictures.FirstOrDefault(p => p.Id.Equals(value)) ?? this) != this) + { throw new ArgumentException($"The picture ID '{value}' already exists."); + } - _id = value; + id = value; } } public MemoryStream ImageStream { get; private set; } - public Int32 Left + public float Left { - get { return Markers[XLMarkerPosition.TopLeft]?.Offset.X ?? 0; } + get + { + ThrowIfDisposed(); + + return Markers[XLMarkerPosition.TopLeft]?.Offset.X ?? 0; + } set { - if (this.Placement != XLPicturePlacement.FreeFloating) + ThrowIfDisposed(); + + if (Placement != XLPicturePlacement.FreeFloating) + { throw new ArgumentException("To set the left-hand offset, the placement should be FreeFloating"); + } - Markers[XLMarkerPosition.TopLeft] = new XLMarker(Worksheet.Cell(1, 1), new Point(value, this.Top)); + Markers[XLMarkerPosition.TopLeft] = new XLMarker(Worksheet.Cell(1, 1), new SKPoint(value, Top)); } } - public String Name + public string Name { - get { return _name; } + get + { + ThrowIfDisposed(); + + return name; + } set { - if (_name == value) return; + ThrowIfDisposed(); + + if (name == value) + { + return; + } if ((Worksheet.Pictures.FirstOrDefault(p => p.Name.Equals(value, StringComparison.OrdinalIgnoreCase)) ?? this) != this) + { throw new ArgumentException($"The picture name '{value}' already exists."); + } SetName(value); } } - public Int32 OriginalHeight { get; private set; } + public int OriginalHeight { get; private set; } - public Int32 OriginalWidth { get; private set; } + public int OriginalWidth { get; private set; } public XLPicturePlacement Placement { get; set; } - public Int32 Top + public float Top { - get { return Markers[XLMarkerPosition.TopLeft]?.Offset.Y ?? 0; } + get + { + ThrowIfDisposed(); + + return Markers[XLMarkerPosition.TopLeft]?.Offset.Y ?? 0; + } set { - if (this.Placement != XLPicturePlacement.FreeFloating) + ThrowIfDisposed(); + + if (Placement != XLPicturePlacement.FreeFloating) + { throw new ArgumentException("To set the top offset, the placement should be FreeFloating"); + } - Markers[XLMarkerPosition.TopLeft] = new XLMarker(Worksheet.Cell(1, 1), new Point(this.Left, value)); + Markers[XLMarkerPosition.TopLeft] = new XLMarker(Worksheet.Cell(1, 1), new SKPoint(Left, value)); } } @@ -188,26 +291,42 @@ public IXLCell TopLeftCell { get { + ThrowIfDisposed(); + return Markers[XLMarkerPosition.TopLeft].Cell; } private set { - if (!value.Worksheet.Equals(this.Worksheet)) + ThrowIfDisposed(); + + if (!value.Worksheet.Equals(Worksheet)) + { throw new InvalidOperationException("A picture and its anchor cells must be on the same worksheet"); + } - this.Markers[XLMarkerPosition.TopLeft] = new XLMarker(value); + Markers[XLMarkerPosition.TopLeft] = new XLMarker(value); } } - public Int32 Width + public int Width { - get { return _width; } + get + { + ThrowIfDisposed(); + + return width; + } set { - if (this.Placement == XLPicturePlacement.MoveAndSize) + ThrowIfDisposed(); + + if (Placement == XLPicturePlacement.MoveAndSize) + { throw new ArgumentException("To set the width, the placement should be FreeFloating or Move"); - _width = value; + } + + width = value; } } @@ -215,7 +334,7 @@ public Int32 Width internal IDictionary Markers { get; private set; } - internal String RelId { get; set; } + internal string RelId { get; set; } /// /// Create a copy of the picture on a different worksheet. @@ -224,40 +343,47 @@ public Int32 Width /// A created copy of the picture. public IXLPicture CopyTo(IXLWorksheet targetSheet) { + ThrowIfDisposed(); + return CopyTo((XLWorksheet)targetSheet); } public void Delete() { - Worksheet.Pictures.Delete(this.Name); - } + ThrowIfDisposed(); - #region IDisposable - - // Used by Janitor.Fody - private void DisposeManaged() - { - this.ImageStream.Dispose(); + Worksheet.Pictures.Delete(Name); } -#if _NET40_ - public void Dispose() { - // net40 doesn't support Janitor.Fody, so let's dispose manually - DisposeManaged(); + Dispose(true); + GC.SuppressFinalize(this); } -#else - - public void Dispose() + public void Dispose(bool disposing) { - // Leave this empty (for non net40 targets) so that Janitor.Fody can do its work - } + if (_disposed) + { + return; + } + + if (disposing) + { + ImageStream?.Dispose(); + codec?.Dispose(); + } -#endif + _disposed = true; + } - #endregion IDisposable + private void ThrowIfDisposed() + { + if (_disposed) + { + throw new ObjectDisposedException("TemplateClass"); + } + } /// /// Create a copy of the picture on the same worksheet. @@ -265,106 +391,154 @@ public void Dispose() /// A created copy of the picture. public IXLPicture Duplicate() { + ThrowIfDisposed(); + return CopyTo(Worksheet); } - public Point GetOffset(XLMarkerPosition position) + public SKPoint GetOffset(XLMarkerPosition position) { + ThrowIfDisposed(); + return Markers[position].Offset; } - public IXLPicture MoveTo(Int32 left, Int32 top) + public IXLPicture MoveTo(float left, float top) { - this.Placement = XLPicturePlacement.FreeFloating; - this.Left = left; - this.Top = top; + ThrowIfDisposed(); + + Placement = XLPicturePlacement.FreeFloating; + Left = left; + Top = top; return this; } public IXLPicture MoveTo(IXLCell cell) { + ThrowIfDisposed(); + return MoveTo(cell, 0, 0); } - public IXLPicture MoveTo(IXLCell cell, Int32 xOffset, Int32 yOffset) + public IXLPicture MoveTo(IXLCell cell, int xOffset, int yOffset) { - return MoveTo(cell, new Point(xOffset, yOffset)); + ThrowIfDisposed(); + + return MoveTo(cell, new SKPoint(xOffset, yOffset)); } - public IXLPicture MoveTo(IXLCell cell, Point offset) + public IXLPicture MoveTo(IXLCell cell, SKPoint offset) { - if (cell == null) throw new ArgumentNullException(nameof(cell)); - this.Placement = XLPicturePlacement.Move; - this.TopLeftCell = cell; - this.Markers[XLMarkerPosition.TopLeft].Offset = offset; + ThrowIfDisposed(); + + if (cell == null) + { + throw new ArgumentNullException(nameof(cell)); + } + + Placement = XLPicturePlacement.Move; + TopLeftCell = cell; + Markers[XLMarkerPosition.TopLeft].Offset = offset; return this; } public IXLPicture MoveTo(IXLCell fromCell, IXLCell toCell) { + ThrowIfDisposed(); + return MoveTo(fromCell, 0, 0, toCell, 0, 0); } - public IXLPicture MoveTo(IXLCell fromCell, Int32 fromCellXOffset, Int32 fromCellYOffset, IXLCell toCell, Int32 toCellXOffset, Int32 toCellYOffset) + public IXLPicture MoveTo(IXLCell fromCell, int fromCellXOffset, int fromCellYOffset, IXLCell toCell, int toCellXOffset, int toCellYOffset) { - return MoveTo(fromCell, new Point(fromCellXOffset, fromCellYOffset), toCell, new Point(toCellXOffset, toCellYOffset)); + ThrowIfDisposed(); + + return MoveTo(fromCell, new SKPoint(fromCellXOffset, fromCellYOffset), toCell, new SKPoint(toCellXOffset, toCellYOffset)); } - public IXLPicture MoveTo(IXLCell fromCell, Point fromOffset, IXLCell toCell, Point toOffset) + public IXLPicture MoveTo(IXLCell fromCell, SKPoint fromOffset, IXLCell toCell, SKPoint toOffset) { - if (fromCell == null) throw new ArgumentNullException(nameof(fromCell)); - if (toCell == null) throw new ArgumentNullException(nameof(toCell)); - this.Placement = XLPicturePlacement.MoveAndSize; + ThrowIfDisposed(); + + if (fromCell == null) + { + throw new ArgumentNullException(nameof(fromCell)); + } - this.TopLeftCell = fromCell; - this.Markers[XLMarkerPosition.TopLeft].Offset = fromOffset; + if (toCell == null) + { + throw new ArgumentNullException(nameof(toCell)); + } + + Placement = XLPicturePlacement.MoveAndSize; - this.BottomRightCell = toCell; - this.Markers[XLMarkerPosition.BottomRight].Offset = toOffset; + TopLeftCell = fromCell; + Markers[XLMarkerPosition.TopLeft].Offset = fromOffset; + + BottomRightCell = toCell; + Markers[XLMarkerPosition.BottomRight].Offset = toOffset; return this; } - public IXLPicture Scale(Double factor, Boolean relativeToOriginal = false) + public IXLPicture Scale(double factor, bool relativeToOriginal = false) { - return this.ScaleHeight(factor, relativeToOriginal).ScaleWidth(factor, relativeToOriginal); + ThrowIfDisposed(); + + return ScaleHeight(factor, relativeToOriginal).ScaleWidth(factor, relativeToOriginal); } - public IXLPicture ScaleHeight(Double factor, Boolean relativeToOriginal = false) + public IXLPicture ScaleHeight(double factor, bool relativeToOriginal = false) { - this.Height = Convert.ToInt32((relativeToOriginal ? this.OriginalHeight : this.Height) * factor); + ThrowIfDisposed(); + + Height = Convert.ToInt32((relativeToOriginal ? OriginalHeight : Height) * factor); return this; } - public IXLPicture ScaleWidth(Double factor, Boolean relativeToOriginal = false) + public IXLPicture ScaleWidth(double factor, bool relativeToOriginal = false) { - this.Width = Convert.ToInt32((relativeToOriginal ? this.OriginalWidth : this.Width) * factor); + ThrowIfDisposed(); + + Width = Convert.ToInt32((relativeToOriginal ? OriginalWidth : Width) * factor); return this; } public IXLPicture WithPlacement(XLPicturePlacement value) { - this.Placement = value; + ThrowIfDisposed(); + + Placement = value; return this; } - public IXLPicture WithSize(Int32 width, Int32 height) + public IXLPicture WithSize(int width, int height) { - this.Width = width; - this.Height = height; + ThrowIfDisposed(); + + Width = width; + Height = height; return this; } internal IXLPicture CopyTo(XLWorksheet targetSheet) { + ThrowIfDisposed(); + if (targetSheet == null) + { targetSheet = Worksheet as XLWorksheet; + } IXLPicture newPicture; if (targetSheet == Worksheet) + { newPicture = targetSheet.AddPicture(ImageStream, Format); + } else + { newPicture = targetSheet.AddPicture(ImageStream, Format, Name); + } newPicture = newPicture .WithPlacement(XLPicturePlacement.FreeFloating) @@ -392,59 +566,33 @@ internal IXLPicture CopyTo(XLWorksheet targetSheet) internal void SetName(string value) { - if (String.IsNullOrWhiteSpace(value)) + ThrowIfDisposed(); + + if (string.IsNullOrWhiteSpace(value)) + { throw new ArgumentException("Picture names cannot be empty"); + } if (value.IndexOfAny(InvalidNameChars.ToCharArray()) != -1) + { throw new ArgumentException($"Picture names cannot contain any of the following characters: {InvalidNameChars}"); + } if (value.Length > 31) - throw new ArgumentException("Picture names cannot be more than 31 characters"); - - _name = value; - } - - private static IDictionary BuildFormatMap() - { - var properties = typeof(ImageFormat).GetProperties(BindingFlags.Static | BindingFlags.Public); - return Enum.GetValues(typeof(XLPictureFormat)) - .Cast() - .Where(pf => properties.Any(pi => pi.Name.Equals(pf.ToString(), StringComparison.OrdinalIgnoreCase))) - .ToDictionary( - pf => pf, - pf => properties.Single(pi => pi.Name.Equals(pf.ToString(), StringComparison.OrdinalIgnoreCase)).GetValue(null, null) as ImageFormat - ); - } - - private static ImageFormat FromMimeType(string mimeType) - { - var guid = ImageCodecInfo.GetImageDecoders().FirstOrDefault(c => c.MimeType.Equals(mimeType, StringComparison.OrdinalIgnoreCase))?.FormatID; - if (!guid.HasValue) return null; - var property = typeof(System.Drawing.Imaging.ImageFormat).GetProperties(BindingFlags.Public | BindingFlags.Static) - .FirstOrDefault(pi => (pi.GetValue(null, null) as ImageFormat).Guid.Equals(guid.Value)); - - if (property == null) return null; - return (property.GetValue(null, null) as ImageFormat); - } - - private static string GetMimeType(Image i) - { - var imgguid = i.RawFormat.Guid; - foreach (ImageCodecInfo codec in ImageCodecInfo.GetImageDecoders()) { - if (codec.FormatID == imgguid) - return codec.MimeType; + throw new ArgumentException("Picture names cannot be more than 31 characters"); } - return "image/unknown"; + + name = value; } - private void DeduceDimensionsFromBitmap(Image image) + private void DeduceDimensionsFromBitmap(SKBitmap bitmap) { - this.OriginalWidth = image.Width; - this.OriginalHeight = image.Height; + OriginalWidth = bitmap.Width; + OriginalHeight = bitmap.Height; - this._width = image.Width; - this._height = image.Height; + width = bitmap.Width; + height = bitmap.Height; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Drawings/XLPictures.cs b/ClosedXML/Excel/Drawings/XLPictures.cs index 6e17a7a4f..a50115e53 100644 --- a/ClosedXML/Excel/Drawings/XLPictures.cs +++ b/ClosedXML/Excel/Drawings/XLPictures.cs @@ -1,8 +1,8 @@ -using System; +using SkiaSharp; +using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; -using System.Drawing; using System.IO; using System.Linq; @@ -16,7 +16,7 @@ internal class XLPictures : IXLPictures, IEnumerable public XLPictures(XLWorksheet worksheet) { _worksheet = worksheet; - Deleted = new HashSet(); + Deleted = new HashSet(); } public int Count @@ -25,7 +25,7 @@ public int Count get { return _pictures.Count; } } - internal ICollection Deleted { get; private set; } + internal ICollection Deleted { get; private set; } public IXLPicture Add(Stream stream) { @@ -57,7 +57,7 @@ public IXLPicture Add(Stream stream, XLPictureFormat format, string name) return picture; } - public IXLPicture Add(Bitmap bitmap) + public IXLPicture Add(SKCodec bitmap) { var picture = new XLPicture(_worksheet, bitmap); _pictures.Add(picture); @@ -65,7 +65,7 @@ public IXLPicture Add(Bitmap bitmap) return picture; } - public IXLPicture Add(Bitmap bitmap, string name) + public IXLPicture Add(SKCodec bitmap, string name) { var picture = Add(bitmap); picture.Name = name; @@ -74,13 +74,11 @@ public IXLPicture Add(Bitmap bitmap, string name) public IXLPicture Add(string imageFile) { - using (var fs = File.OpenRead(imageFile)) - { - var picture = new XLPicture(_worksheet, fs); - _pictures.Add(picture); - picture.Name = GetNextPictureName(); - return picture; - } + using var fs = File.OpenRead(imageFile); + var picture = new XLPicture(_worksheet, fs); + _pictures.Add(picture); + picture.Name = GetNextPictureName(); + return picture; } public IXLPicture Add(string imageFile, string name) @@ -107,12 +105,16 @@ public void Delete(string pictureName) .ToList(); if (!picturesToDelete.Any()) + { throw new ArgumentOutOfRangeException(nameof(pictureName), $"Picture {pictureName} was not found."); + } foreach (var picture in picturesToDelete) { if (!string.IsNullOrEmpty(picture.RelId)) + { Deleted.Add(picture.RelId); + } _pictures.Remove(picture); } @@ -135,8 +137,10 @@ IEnumerator IEnumerable.GetEnumerator() public IXLPicture Picture(string pictureName) { - if (TryGetPicture(pictureName, out IXLPicture p)) + if (TryGetPicture(pictureName, out var p)) + { return p; + } throw new ArgumentOutOfRangeException(nameof(pictureName), $"Picture {pictureName} was not found."); } @@ -155,15 +159,16 @@ public bool TryGetPicture(string pictureName, out IXLPicture picture) internal IXLPicture Add(Stream stream, string name, int Id) { + stream.Position = 0; var picture = Add(stream) as XLPicture; picture.SetName(name); picture.Id = Id; return picture; } - private String GetNextPictureName() + private string GetNextPictureName() { - var pictureNumber = this.Count; + var pictureNumber = Count; while (_pictures.Any(p => p.Name == $"Picture {pictureNumber}")) { pictureNumber++; diff --git a/ClosedXML/Excel/Exceptions/ClosedXMLException.cs b/ClosedXML/Excel/Exceptions/ClosedXMLException.cs index 3a0081653..e4f64ac4f 100644 --- a/ClosedXML/Excel/Exceptions/ClosedXMLException.cs +++ b/ClosedXML/Excel/Exceptions/ClosedXMLException.cs @@ -8,11 +8,11 @@ protected ClosedXMLException() : base() { } - protected ClosedXMLException(String message) + protected ClosedXMLException(string message) : base(message) { } - protected ClosedXMLException(String message, Exception innerException) + protected ClosedXMLException(string message, Exception innerException) : base(message, innerException) { } } diff --git a/ClosedXML/Excel/Exceptions/EmptyTableException.cs b/ClosedXML/Excel/Exceptions/EmptyTableException.cs index 1f657e298..67cb7415c 100644 --- a/ClosedXML/Excel/Exceptions/EmptyTableException.cs +++ b/ClosedXML/Excel/Exceptions/EmptyTableException.cs @@ -8,11 +8,11 @@ public EmptyTableException() : base() { } - public EmptyTableException(String message) + public EmptyTableException(string message) : base(message) { } - public EmptyTableException(String message, Exception innerException) + public EmptyTableException(string message, Exception innerException) : base(message, innerException) { } } diff --git a/ClosedXML/Excel/Hyperlinks/XLHyperlink_Internal.cs b/ClosedXML/Excel/Hyperlinks/XLHyperlink_Internal.cs index 370556813..7ed6d86d3 100644 --- a/ClosedXML/Excel/Hyperlinks/XLHyperlink_Internal.cs +++ b/ClosedXML/Excel/Hyperlinks/XLHyperlink_Internal.cs @@ -17,7 +17,7 @@ internal XLHyperlink(XLHyperlink hyperlink) IsExternal = hyperlink.IsExternal; } - internal void SetValues(String address, String tooltip) + internal void SetValues(string address, string tooltip) { Tooltip = tooltip; if (address[0] == '.') @@ -27,7 +27,7 @@ internal void SetValues(String address, String tooltip) } else { - if (Uri.TryCreate(address, UriKind.Absolute, out Uri uri)) + if (Uri.TryCreate(address, UriKind.Absolute, out var uri)) { _externalAddress = uri; IsExternal = true; @@ -40,21 +40,21 @@ internal void SetValues(String address, String tooltip) } } - internal void SetValues(Uri uri, String tooltip) + internal void SetValues(Uri uri, string tooltip) { Tooltip = tooltip; _externalAddress = uri; IsExternal = true; } - internal void SetValues(IXLCell cell, String tooltip) + internal void SetValues(IXLCell cell, string tooltip) { Tooltip = tooltip; _internalAddress = cell.Address.ToString(XLReferenceStyle.A1, true); IsExternal = false; } - internal void SetValues(IXLRangeBase range, String tooltip) + internal void SetValues(IXLRangeBase range, string tooltip) { Tooltip = tooltip; _internalAddress = range.RangeAddress.ToString(XLReferenceStyle.A1, true); diff --git a/ClosedXML/Excel/Hyperlinks/XLHyperlink_public.cs b/ClosedXML/Excel/Hyperlinks/XLHyperlink_public.cs index cbc96f529..e8a320d2c 100644 --- a/ClosedXML/Excel/Hyperlinks/XLHyperlink_public.cs +++ b/ClosedXML/Excel/Hyperlinks/XLHyperlink_public.cs @@ -1,4 +1,3 @@ -using ClosedXML.Extensions; using System; using System.Linq; @@ -7,49 +6,49 @@ namespace ClosedXML.Excel public partial class XLHyperlink { private Uri _externalAddress; - private String _internalAddress; + private string _internalAddress; - public XLHyperlink(String address) + public XLHyperlink(string address) { - SetValues(address, String.Empty); + SetValues(address, string.Empty); } - public XLHyperlink(String address, String tooltip) + public XLHyperlink(string address, string tooltip) { SetValues(address, tooltip); } public XLHyperlink(IXLCell cell) { - SetValues(cell, String.Empty); + SetValues(cell, string.Empty); } - public XLHyperlink(IXLCell cell, String tooltip) + public XLHyperlink(IXLCell cell, string tooltip) { SetValues(cell, tooltip); } public XLHyperlink(IXLRangeBase range) { - SetValues(range, String.Empty); + SetValues(range, string.Empty); } - public XLHyperlink(IXLRangeBase range, String tooltip) + public XLHyperlink(IXLRangeBase range, string tooltip) { SetValues(range, tooltip); } public XLHyperlink(Uri uri) { - SetValues(uri, String.Empty); + SetValues(uri, string.Empty); } - public XLHyperlink(Uri uri, String tooltip) + public XLHyperlink(Uri uri, string tooltip) { SetValues(uri, tooltip); } - public Boolean IsExternal { get; set; } + public bool IsExternal { get; set; } public Uri ExternalAddress { @@ -66,16 +65,19 @@ public Uri ExternalAddress public IXLCell Cell { get; internal set; } - public String InternalAddress + public string InternalAddress { get { if (IsExternal) + { return null; + } + if (_internalAddress.Contains('!')) { return _internalAddress[0] != '\'' - ? String.Concat( + ? string.Concat( _internalAddress .Substring(0, _internalAddress.IndexOf('!')) .EscapeSheetName(), @@ -83,7 +85,7 @@ public String InternalAddress _internalAddress.Substring(_internalAddress.IndexOf('!') + 1)) : _internalAddress; } - return String.Concat( + return string.Concat( Worksheet.Name.EscapeSheetName(), '!', _internalAddress); @@ -95,14 +97,20 @@ public String InternalAddress } } - public String Tooltip { get; set; } + public string Tooltip { get; set; } public void Delete() { - if (Cell == null) return; + if (Cell == null) + { + return; + } + Worksheet.Hyperlinks.Delete(Cell.Address); if (Cell.Style.Font.FontColor.Equals(XLColor.FromTheme(XLThemeColor.Hyperlink))) + { Cell.Style.Font.FontColor = Worksheet.StyleValue.Font.FontColor; + } Cell.Style.Font.Underline = Worksheet.StyleValue.Font.Underline; } diff --git a/ClosedXML/Excel/IXLFileSharing.cs b/ClosedXML/Excel/IXLFileSharing.cs index d75c18e02..a142d40b1 100644 --- a/ClosedXML/Excel/IXLFileSharing.cs +++ b/ClosedXML/Excel/IXLFileSharing.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -7,11 +6,11 @@ public interface IXLFileSharing { //String AlgorithmName { get; set; } //Byte[] HashValue { get; set; } - Boolean ReadOnlyRecommended { get; set; } + bool ReadOnlyRecommended { get; set; } //Byte[] ReservationPassword { get; set; } //Byte[] SaltValue { get; set; } //Int32 SpinCount { get; set; } - String UserName { get; set; } + string UserName { get; set; } } } diff --git a/ClosedXML/Excel/IXLSheetView.cs b/ClosedXML/Excel/IXLSheetView.cs index 7a7f14eb8..ff09699bf 100644 --- a/ClosedXML/Excel/IXLSheetView.cs +++ b/ClosedXML/Excel/IXLSheetView.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -10,12 +9,12 @@ public interface IXLSheetView /// /// Gets or sets the column after which the horizontal split should take place. /// - Int32 SplitColumn { get; set; } + int SplitColumn { get; set; } /// /// Gets or sets the row after which the vertical split should take place. /// - Int32 SplitRow { get; set; } + int SplitRow { get; set; } /// /// Gets or sets the location of the top left visible cell @@ -33,45 +32,45 @@ public interface IXLSheetView /// Window zoom magnification for current view representing percent values. Horizontal and vertical scale together. /// /// Representing percent values ranging from 10 to 400. - Int32 ZoomScale { get; set; } + int ZoomScale { get; set; } /// /// Zoom magnification to use when in normal view. Horizontal and vertical scale together /// /// Representing percent values ranging from 10 to 400. - Int32 ZoomScaleNormal { get; set; } + int ZoomScaleNormal { get; set; } /// /// Zoom magnification to use when in page layout view. Horizontal and vertical scale together. /// /// Representing percent values ranging from 10 to 400. - Int32 ZoomScalePageLayoutView { get; set; } + int ZoomScalePageLayoutView { get; set; } /// /// Zoom magnification to use when in page break preview. Horizontal and vertical scale together. /// /// Representing percent values ranging from 10 to 400. - Int32 ZoomScaleSheetLayoutView { get; set; } + int ZoomScaleSheetLayoutView { get; set; } /// /// Freezes the specified rows and columns. /// /// The rows to freeze. /// The columns to freeze. - void Freeze(Int32 rows, Int32 columns); + void Freeze(int rows, int columns); /// /// Freezes the left X columns. /// /// The columns to freeze. - void FreezeColumns(Int32 columns); + void FreezeColumns(int columns); //Boolean FreezePanes { get; set; } /// /// Freezes the top X rows. /// /// The rows to freeze. - void FreezeRows(Int32 rows); + void FreezeRows(int rows); IXLSheetView SetView(XLSheetViewOptions value); } diff --git a/ClosedXML/Excel/IXLWorkbook.cs b/ClosedXML/Excel/IXLWorkbook.cs index 49f84afc2..6ce84aea1 100644 --- a/ClosedXML/Excel/IXLWorkbook.cs +++ b/ClosedXML/Excel/IXLWorkbook.cs @@ -9,54 +9,54 @@ namespace ClosedXML.Excel { public interface IXLWorkbook : IXLProtectable, IDisposable { - String Author { get; set; } + string Author { get; set; } /// /// Gets or sets the workbook's calculation mode. /// XLCalculateMode CalculateMode { get; set; } - Boolean CalculationOnSave { get; set; } + bool CalculationOnSave { get; set; } /// /// Gets or sets the default column width for the workbook. /// All new worksheets will use this column width. /// - Double ColumnWidth { get; set; } + double ColumnWidth { get; set; } IXLCustomProperties CustomProperties { get; } - Boolean DefaultRightToLeft { get; } + bool DefaultRightToLeft { get; } - Boolean DefaultShowFormulas { get; } + bool DefaultShowFormulas { get; } - Boolean DefaultShowGridLines { get; } + bool DefaultShowGridLines { get; } - Boolean DefaultShowOutlineSymbols { get; } + bool DefaultShowOutlineSymbols { get; } - Boolean DefaultShowRowColHeaders { get; } + bool DefaultShowRowColHeaders { get; } - Boolean DefaultShowRuler { get; } + bool DefaultShowRuler { get; } - Boolean DefaultShowWhiteSpace { get; } + bool DefaultShowWhiteSpace { get; } - Boolean DefaultShowZeros { get; } + bool DefaultShowZeros { get; } IXLFileSharing FileSharing { get; } - Boolean ForceFullCalculation { get; set; } + bool ForceFullCalculation { get; set; } - Boolean FullCalculationOnLoad { get; set; } + bool FullCalculationOnLoad { get; set; } - Boolean FullPrecision { get; set; } + bool FullPrecision { get; set; } //Boolean IsPasswordProtected { get; } //Boolean IsProtected { get; } - Boolean LockStructure { get; set; } + bool LockStructure { get; set; } - Boolean LockWindows { get; set; } + bool LockWindows { get; set; } /// /// Gets an object to manipulate this workbook's named ranges. @@ -85,27 +85,27 @@ public interface IXLWorkbook : IXLProtectable XLReferenceStyle ReferenceStyle { get; set; } - Boolean RightToLeft { get; set; } + bool RightToLeft { get; set; } /// /// Gets or sets the default row height for the workbook. /// All new worksheets will use this row height. /// - Double RowHeight { get; set; } + double RowHeight { get; set; } - Boolean ShowFormulas { get; set; } + bool ShowFormulas { get; set; } - Boolean ShowGridLines { get; set; } + bool ShowGridLines { get; set; } - Boolean ShowOutlineSymbols { get; set; } + bool ShowOutlineSymbols { get; set; } - Boolean ShowRowColHeaders { get; set; } + bool ShowRowColHeaders { get; set; } - Boolean ShowRuler { get; set; } + bool ShowRuler { get; set; } - Boolean ShowWhiteSpace { get; set; } + bool ShowWhiteSpace { get; set; } - Boolean ShowZeros { get; set; } + bool ShowZeros { get; set; } /// /// Gets or sets the default style for the workbook. @@ -118,7 +118,7 @@ public interface IXLWorkbook : IXLProtectable IXLTheme Theme { get; } - Boolean Use1904DateSystem { get; set; } + bool Use1904DateSystem { get; set; } /// /// Gets an object to manipulate the worksheets. @@ -127,11 +127,11 @@ public interface IXLWorkbook : IXLProtectable predicate); + IXLCells FindCells(Func predicate); - IXLColumns FindColumns(Func predicate); + IXLColumns FindColumns(Func predicate); - IXLRows FindRows(Func predicate); + IXLRows FindRows(Func predicate); - IXLNamedRange NamedRange(String rangeName); + IXLNamedRange NamedRange(string rangeName); [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - IXLWorkbookProtection Protect(Boolean lockStructure, Boolean lockWindows, String password); + IXLWorkbookProtection Protect(bool lockStructure, bool lockWindows, string password); [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - IXLWorkbookProtection Protect(Boolean lockStructure); + IXLWorkbookProtection Protect(bool lockStructure); [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - IXLWorkbookProtection Protect(Boolean lockStructure, Boolean lockWindows); + IXLWorkbookProtection Protect(bool lockStructure, bool lockWindows); - IXLRange Range(String range); + IXLRange Range(string range); - IXLRange RangeFromFullAddress(String rangeAddress, out IXLWorksheet ws); + IXLRange RangeFromFullAddress(string rangeAddress, out IXLWorksheet ws); - IXLRanges Ranges(String ranges); + IXLRanges Ranges(string ranges); /// /// Force recalculation of all cell formulas. @@ -185,21 +185,21 @@ public interface IXLWorkbook : IXLProtectable /// Saves the current workbook and optionally performs validation /// - void Save(Boolean validate, Boolean evaluateFormulae = false); + void Save(bool validate, bool evaluateFormulae = false); void Save(SaveOptions options); /// /// Saves the current workbook to a file. /// - void SaveAs(String file); + void SaveAs(string file); /// /// Saves the current workbook to a file and optionally validates it. /// - void SaveAs(String file, Boolean validate, Boolean evaluateFormulae = false); + void SaveAs(string file, bool validate, bool evaluateFormulae = false); - void SaveAs(String file, SaveOptions options); + void SaveAs(string file, SaveOptions options); /// /// Saves the current workbook to a stream. @@ -209,7 +209,7 @@ public interface IXLWorkbook : IXLProtectable /// Saves the current workbook to a stream and optionally validates it. /// - void SaveAs(Stream stream, Boolean validate, Boolean evaluateFormulae = false); + void SaveAs(Stream stream, bool validate, bool evaluateFormulae = false); void SaveAs(Stream stream, SaveOptions options); @@ -220,15 +220,15 @@ public interface IXLWorkbook : IXLProtectableThe compare options. /// if set to true search formulae instead of cell values. /// - IEnumerable Search(String searchText, CompareOptions compareOptions = CompareOptions.Ordinal, Boolean searchFormulae = false); + IEnumerable Search(string searchText, CompareOptions compareOptions = CompareOptions.Ordinal, bool searchFormulae = false); - XLWorkbook SetLockStructure(Boolean value); + XLWorkbook SetLockStructure(bool value); - XLWorkbook SetLockWindows(Boolean value); + XLWorkbook SetLockWindows(bool value); XLWorkbook SetUse1904DateSystem(); - XLWorkbook SetUse1904DateSystem(Boolean value); + XLWorkbook SetUse1904DateSystem(bool value); /// /// Gets the Excel table of the given name @@ -237,12 +237,12 @@ public interface IXLWorkbook : IXLProtectableOne of the enumeration values that specifies how the strings will be compared. /// The table with given name /// If no tables with this name could be found in the workbook. - IXLTable Table(String tableName, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase); + IXLTable Table(string tableName, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase); - Boolean TryGetWorksheet(String name, out IXLWorksheet worksheet); + bool TryGetWorksheet(string name, out IXLWorksheet worksheet); - IXLWorksheet Worksheet(String name); + IXLWorksheet Worksheet(string name); - IXLWorksheet Worksheet(Int32 position); + IXLWorksheet Worksheet(int position); } } diff --git a/ClosedXML/Excel/IXLWorksheet.cs b/ClosedXML/Excel/IXLWorksheet.cs index 0793ad340..59258f136 100644 --- a/ClosedXML/Excel/IXLWorksheet.cs +++ b/ClosedXML/Excel/IXLWorksheet.cs @@ -1,11 +1,12 @@ using ClosedXML.Excel.Drawings; +using SkiaSharp; using System; -using System.Drawing; using System.IO; namespace ClosedXML.Excel { - public enum XLWorksheetVisibility { Visible, Hidden, VeryHidden } + public enum XLWorksheetVisibility + { Visible, Hidden, VeryHidden } public interface IXLWorksheet : IXLRangeBase, IXLProtectable { @@ -17,23 +18,23 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// Gets or sets the default column width for this worksheet. /// - Double ColumnWidth { get; set; } + double ColumnWidth { get; set; } /// /// Gets or sets the default row height for this worksheet. /// - Double RowHeight { get; set; } + double RowHeight { get; set; } /// /// Gets or sets the name (caption) of this worksheet. /// - String Name { get; set; } + string Name { get; set; } /// /// Gets or sets the position of the sheet. /// When setting the Position all other sheets' positions are shifted accordingly. /// - Int32 Position { get; set; } + int Position { get; set; } /// /// Gets an object to manipulate the sheet's print options. @@ -61,7 +62,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// If set to true formatted empty cells will count as used. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRow FirstRowUsed(Boolean includeFormats); + IXLRow FirstRowUsed(bool includeFormats); IXLRow FirstRowUsed(XLCellsUsedOptions options); @@ -80,7 +81,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// If set to true formatted empty cells will count as used. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRow LastRowUsed(Boolean includeFormats); + IXLRow LastRowUsed(bool includeFormats); IXLRow LastRowUsed(XLCellsUsedOptions options); @@ -99,7 +100,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// If set to true formatted empty cells will count as used. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLColumn FirstColumnUsed(Boolean includeFormats); + IXLColumn FirstColumnUsed(bool includeFormats); IXLColumn FirstColumnUsed(XLCellsUsedOptions options); @@ -118,7 +119,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// If set to true formatted empty cells will count as used. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLColumn LastColumnUsed(Boolean includeFormats); + IXLColumn LastColumnUsed(bool includeFormats); IXLColumn LastColumnUsed(XLCellsUsedOptions options); @@ -132,21 +133,21 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectablee.g. Columns("G:H"), Columns("10:11,13:14"), Columns("P:Q,S:T"), Columns("V") /// /// The columns to return. - IXLColumns Columns(String columns); + IXLColumns Columns(string columns); /// /// Gets a collection of the specified columns in this worksheet. /// /// The first column to return. /// The last column to return. - IXLColumns Columns(String firstColumn, String lastColumn); + IXLColumns Columns(string firstColumn, string lastColumn); /// /// Gets a collection of the specified columns in this worksheet. /// /// The first column to return. /// The last column to return. - IXLColumns Columns(Int32 firstColumn, Int32 lastColumn); + IXLColumns Columns(int firstColumn, int lastColumn); /// /// Gets a collection of all rows in this worksheet. @@ -158,7 +159,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectablee.g. Rows("4:5"), Rows("7:8,10:11"), Rows("13") /// /// The rows to return. - IXLRows Rows(String rows); + IXLRows Rows(string rows); /// /// Gets a collection of the specified rows in this worksheet. @@ -166,25 +167,25 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectableThe first row to return. /// The last row to return. /// - IXLRows Rows(Int32 firstRow, Int32 lastRow); + IXLRows Rows(int firstRow, int lastRow); /// /// Gets the specified row of the worksheet. /// /// The worksheet's row. - IXLRow Row(Int32 row); + IXLRow Row(int row); /// /// Gets the specified column of the worksheet. /// /// The worksheet's column. - IXLColumn Column(Int32 column); + IXLColumn Column(int column); /// /// Gets the specified column of the worksheet. /// /// The worksheet's column. - IXLColumn Column(String column); + IXLColumn Column(string column); /// /// Gets the cell at the specified row and column. @@ -277,25 +278,25 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// The outline level. - IXLWorksheet CollapseRows(Int32 outlineLevel); + IXLWorksheet CollapseRows(int outlineLevel); /// /// Collapses the outlined columns of the specified level. /// /// The outline level. - IXLWorksheet CollapseColumns(Int32 outlineLevel); + IXLWorksheet CollapseColumns(int outlineLevel); /// /// Expands the outlined rows of the specified level. /// /// The outline level. - IXLWorksheet ExpandRows(Int32 outlineLevel); + IXLWorksheet ExpandRows(int outlineLevel); /// /// Expands the outlined columns of the specified level. /// /// The outline level. - IXLWorksheet ExpandColumns(Int32 outlineLevel); + IXLWorksheet ExpandColumns(int outlineLevel); /// /// Deletes this worksheet. @@ -311,7 +312,7 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// Name of the range. - IXLNamedRange NamedRange(String rangeName); + IXLNamedRange NamedRange(string rangeName); /// /// Gets an object to manage how the worksheet is going to displayed by Excel. @@ -322,13 +323,13 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// Index of the table to return - IXLTable Table(Int32 index); + IXLTable Table(int index); /// /// Gets the Excel table of the given name /// /// Name of the table to return - IXLTable Table(String name); + IXLTable Table(string name); /// /// Gets an object to manage this worksheet's Excel tables @@ -340,15 +341,15 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// /// - IXLWorksheet CopyTo(String newSheetName); + IXLWorksheet CopyTo(string newSheetName); - IXLWorksheet CopyTo(String newSheetName, Int32 position); + IXLWorksheet CopyTo(string newSheetName, int position); IXLWorksheet CopyTo(XLWorkbook workbook); - IXLWorksheet CopyTo(XLWorkbook workbook, String newSheetName); + IXLWorksheet CopyTo(XLWorkbook workbook, string newSheetName); - IXLWorksheet CopyTo(XLWorkbook workbook, String newSheetName, Int32 position); + IXLWorksheet CopyTo(XLWorkbook workbook, string newSheetName, int position); IXLRange RangeUsed(); @@ -371,77 +372,77 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable predicate = null); + IXLRows RowsUsed(bool includeFormats, Func predicate = null); - IXLRows RowsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null); + IXLRows RowsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null); - IXLRows RowsUsed(Func predicate); + IXLRows RowsUsed(Func predicate); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLColumns ColumnsUsed(Boolean includeFormats, Func predicate = null); + IXLColumns ColumnsUsed(bool includeFormats, Func predicate = null); - IXLColumns ColumnsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null); + IXLColumns ColumnsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null); - IXLColumns ColumnsUsed(Func predicate); + IXLColumns ColumnsUsed(Func predicate); IXLRanges MergedRanges { get; } @@ -453,33 +454,33 @@ public interface IXLWorksheet : IXLRangeBase, IXLProtectable /// Force recalculation of all cell formulas. /// void RecalculateAllFormulas(); - String Author { get; set; } + string Author { get; set; } IXLPictures Pictures { get; } - IXLPicture Picture(String pictureName); + IXLPicture Picture(string pictureName); IXLPicture AddPicture(Stream stream); - IXLPicture AddPicture(Stream stream, String name); + IXLPicture AddPicture(Stream stream, string name); IXLPicture AddPicture(Stream stream, XLPictureFormat format); - IXLPicture AddPicture(Stream stream, XLPictureFormat format, String name); + IXLPicture AddPicture(Stream stream, XLPictureFormat format, string name); - IXLPicture AddPicture(Bitmap bitmap); + IXLPicture AddPicture(SKCodec bitmap); - IXLPicture AddPicture(Bitmap bitmap, String name); + IXLPicture AddPicture(SKCodec bitmap, string name); - IXLPicture AddPicture(String imageFile); + IXLPicture AddPicture(string imageFile); - IXLPicture AddPicture(String imageFile, String name); + IXLPicture AddPicture(string imageFile, string name); } } diff --git a/ClosedXML/Excel/IXLWorksheets.cs b/ClosedXML/Excel/IXLWorksheets.cs index ea79b0b81..ff7166e58 100644 --- a/ClosedXML/Excel/IXLWorksheets.cs +++ b/ClosedXML/Excel/IXLWorksheets.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; using System.Data; @@ -10,28 +9,28 @@ public interface IXLWorksheets : IEnumerable IXLWorksheet Add(); - IXLWorksheet Add(Int32 position); + IXLWorksheet Add(int position); - IXLWorksheet Add(String sheetName); + IXLWorksheet Add(string sheetName); - IXLWorksheet Add(String sheetName, Int32 position); + IXLWorksheet Add(string sheetName, int position); IXLWorksheet Add(DataTable dataTable); - IXLWorksheet Add(DataTable dataTable, String sheetName); + IXLWorksheet Add(DataTable dataTable, string sheetName); void Add(DataSet dataSet); - Boolean Contains(String sheetName); + bool Contains(string sheetName); - void Delete(String sheetName); + void Delete(string sheetName); - void Delete(Int32 position); + void Delete(int position); bool TryGetWorksheet(string sheetName, out IXLWorksheet worksheet); - IXLWorksheet Worksheet(String sheetName); + IXLWorksheet Worksheet(string sheetName); - IXLWorksheet Worksheet(Int32 position); + IXLWorksheet Worksheet(int position); } } diff --git a/ClosedXML/Excel/InsertData/ArrayReader.cs b/ClosedXML/Excel/InsertData/ArrayReader.cs index a33df5b2a..ae8139b68 100644 --- a/ClosedXML/Excel/InsertData/ArrayReader.cs +++ b/ClosedXML/Excel/InsertData/ArrayReader.cs @@ -23,7 +23,9 @@ public IEnumerable> GetData() public int GetPropertiesCount() { if (!_data.Any()) + { return 0; + } return _data.First().Cast().Count(); } diff --git a/ClosedXML/Excel/InsertData/DataRecordReader.cs b/ClosedXML/Excel/InsertData/DataRecordReader.cs index 070e5567e..6dfb51944 100644 --- a/ClosedXML/Excel/InsertData/DataRecordReader.cs +++ b/ClosedXML/Excel/InsertData/DataRecordReader.cs @@ -13,7 +13,10 @@ internal class DataRecordReader : IInsertDataReader public DataRecordReader(IEnumerable data) { - if (data == null) throw new ArgumentNullException(nameof(data)); + if (data == null) + { + throw new ArgumentNullException(nameof(data)); + } _inMemoryData = ReadToEnd(data).ToArray(); } @@ -31,13 +34,19 @@ public int GetPropertiesCount() public string GetPropertyName(int propertyIndex) { if (propertyIndex < 0) + { throw new ArgumentOutOfRangeException(nameof(propertyIndex), "Property index must be non-negative"); + } if (_columns == null) + { return null; + } if (propertyIndex >= _columns.Length) + { throw new ArgumentOutOfRangeException($"{propertyIndex} exceeds the number of the table columns"); + } return _columns[propertyIndex]; } @@ -64,10 +73,12 @@ private IEnumerable ToEnumerable(IDataRecord dataRecord) _columns = new string[dataRecord.FieldCount]; } - for (int i = 0; i < dataRecord.FieldCount; i++) + for (var i = 0; i < dataRecord.FieldCount; i++) { if (firstRow) + { _columns[i] = dataRecord.GetName(i); + } yield return dataRecord[i]; } diff --git a/ClosedXML/Excel/InsertData/DataTableReader.cs b/ClosedXML/Excel/InsertData/DataTableReader.cs index 4d6ecdd71..64e3dc958 100644 --- a/ClosedXML/Excel/InsertData/DataTableReader.cs +++ b/ClosedXML/Excel/InsertData/DataTableReader.cs @@ -30,10 +30,14 @@ public IEnumerable> GetData() public int GetPropertiesCount() { if (_dataTable != null) + { return _dataTable.Columns.Count; + } if (_dataRows.Any()) + { return _dataRows.First().ItemArray.Length; + } return 0; } @@ -41,13 +45,19 @@ public int GetPropertiesCount() public string GetPropertyName(int propertyIndex) { if (propertyIndex < 0) + { throw new ArgumentOutOfRangeException(nameof(propertyIndex), "Property index must be non-negative"); + } if (_dataTable == null) + { return null; + } if (propertyIndex >= _dataTable.Columns.Count) + { throw new ArgumentOutOfRangeException($"{propertyIndex} exceeds the number of the table columns"); + } return _dataTable.Columns[propertyIndex].Caption; } diff --git a/ClosedXML/Excel/InsertData/InsertDataReaderFactory.cs b/ClosedXML/Excel/InsertData/InsertDataReaderFactory.cs index c85caa3ff..64e66fb61 100644 --- a/ClosedXML/Excel/InsertData/InsertDataReaderFactory.cs +++ b/ClosedXML/Excel/InsertData/InsertDataReaderFactory.cs @@ -16,46 +16,72 @@ internal class InsertDataReaderFactory public IInsertDataReader CreateReader(IEnumerable data) { - if (data == null) throw new ArgumentNullException(nameof(data)); + if (data == null) + { + throw new ArgumentNullException(nameof(data)); + } var itemType = data.GetItemType(); - if (itemType == null || itemType == typeof(Object)) + if (itemType == null || itemType == typeof(object)) + { return new UntypedObjectReader(data); + } else if (itemType.IsNullableType() && itemType.GetUnderlyingType().IsSimpleType()) + { return new SimpleNullableTypeReader(data); + } else if (itemType.IsSimpleType()) + { return new SimpleTypeReader(data); + } else if (typeof(IDataRecord).IsAssignableFrom(itemType)) + { return new DataRecordReader(data.OfType()); + } else if (itemType.IsArray || typeof(IEnumerable).IsAssignableFrom(itemType)) + { return new ArrayReader(data.Cast()); + } else if (itemType == typeof(DataRow)) + { return new DataTableReader(data.Cast()); + } return new ObjectReader(data); } public IInsertDataReader CreateReader(IEnumerable data) { - if (data == null) throw new ArgumentNullException(nameof(data)); + if (data == null) + { + throw new ArgumentNullException(nameof(data)); + } return new ArrayReader(data); } public IInsertDataReader CreateReader(IEnumerable data) { - if (data == null) throw new ArgumentNullException(nameof(data)); + if (data == null) + { + throw new ArgumentNullException(nameof(data)); + } - if (data?.GetType().GetElementType() == typeof(String)) + if (data?.GetType().GetElementType() == typeof(string)) + { return new SimpleTypeReader(data); + } return new ArrayReader(data); } public IInsertDataReader CreateReader(DataTable dataTable) { - if (dataTable == null) throw new ArgumentNullException(nameof(dataTable)); + if (dataTable == null) + { + throw new ArgumentNullException(nameof(dataTable)); + } return new DataTableReader(dataTable); } diff --git a/ClosedXML/Excel/InsertData/NullDataReader.cs b/ClosedXML/Excel/InsertData/NullDataReader.cs index 825aafffd..9088993ca 100644 --- a/ClosedXML/Excel/InsertData/NullDataReader.cs +++ b/ClosedXML/Excel/InsertData/NullDataReader.cs @@ -16,7 +16,7 @@ public NullDataReader(IEnumerable nulls) public IEnumerable> GetData() { var res = new object[] { null }.AsEnumerable(); - for (int i = 0; i < _count; i++) + for (var i = 0; i < _count; i++) { yield return res; } diff --git a/ClosedXML/Excel/InsertData/ObjectReader.cs b/ClosedXML/Excel/InsertData/ObjectReader.cs index 48411f6ee..15d9abe88 100644 --- a/ClosedXML/Excel/InsertData/ObjectReader.cs +++ b/ClosedXML/Excel/InsertData/ObjectReader.cs @@ -25,7 +25,9 @@ public ObjectReader(IEnumerable data) var itemType = data.GetItemType(); if (itemType.IsNullableType()) + { itemType = itemType.GetUnderlyingType(); + } _members = itemType.GetFields(bindingFlags).Cast() .Concat(itemType.GetProperties(bindingFlags)) @@ -49,15 +51,21 @@ public int GetPropertiesCount() public string GetPropertyName(int propertyIndex) { if (propertyIndex < 0) + { throw new ArgumentOutOfRangeException(nameof(propertyIndex), "Property index must be non-negative"); + } if (propertyIndex >= GetPropertiesCount()) + { throw new ArgumentOutOfRangeException($"{propertyIndex} exceeds the number of the object properties"); + } var memberInfo = _members[propertyIndex]; var fieldName = XLColumnAttribute.GetHeader(memberInfo); - if (String.IsNullOrWhiteSpace(fieldName)) + if (string.IsNullOrWhiteSpace(fieldName)) + { fieldName = memberInfo.Name; + } return fieldName; } @@ -69,7 +77,7 @@ public int GetRecordsCount() private IEnumerable GetItemData(object item) { - for (int i = 0; i < _members.Length; i++) + for (var i = 0; i < _members.Length; i++) { if (item == null) { diff --git a/ClosedXML/Excel/InsertData/SimpleNullableTypeReader.cs b/ClosedXML/Excel/InsertData/SimpleNullableTypeReader.cs index d7c019420..6318a8a29 100644 --- a/ClosedXML/Excel/InsertData/SimpleNullableTypeReader.cs +++ b/ClosedXML/Excel/InsertData/SimpleNullableTypeReader.cs @@ -30,7 +30,9 @@ public int GetPropertiesCount() public string GetPropertyName(int propertyIndex = 0) { if (propertyIndex != 0) + { throw new ArgumentException("SimpleNullableTypeReader supports only a single property"); + } return _itemType.Name; } diff --git a/ClosedXML/Excel/InsertData/SimpleTypeReader.cs b/ClosedXML/Excel/InsertData/SimpleTypeReader.cs index b94cc9a35..ed45480da 100644 --- a/ClosedXML/Excel/InsertData/SimpleTypeReader.cs +++ b/ClosedXML/Excel/InsertData/SimpleTypeReader.cs @@ -30,7 +30,9 @@ public int GetPropertiesCount() public string GetPropertyName(int propertyIndex = 0) { if (propertyIndex != 0) + { throw new ArgumentException("SimpleTypeReader supports only a single property"); + } return _itemType.Name; } diff --git a/ClosedXML/Excel/InsertData/UntypedObjectReader.cs b/ClosedXML/Excel/InsertData/UntypedObjectReader.cs index 13869a7c1..723f82111 100644 --- a/ClosedXML/Excel/InsertData/UntypedObjectReader.cs +++ b/ClosedXML/Excel/InsertData/UntypedObjectReader.cs @@ -19,9 +19,11 @@ public UntypedObjectReader(IEnumerable data) IEnumerable CreateReaders() { if (!_data.Any()) + { yield break; + } - List itemsOfSameType = new List(); + var itemsOfSameType = new List(); Type previousType = null; foreach (var item in _data) @@ -46,7 +48,9 @@ IEnumerable CreateReaders() IInsertDataReader CreateReader(List itemsOfSameType, Type itemType) { if (itemType == null) + { return new NullDataReader(itemsOfSameType); + } var items = Array.CreateInstance(itemType, itemsOfSameType.Count); Array.Copy(itemsOfSameType.ToArray(), items, items.Length); diff --git a/ClosedXML/Excel/LoadOptions.cs b/ClosedXML/Excel/LoadOptions.cs index 3f4afc593..e1814de71 100644 --- a/ClosedXML/Excel/LoadOptions.cs +++ b/ClosedXML/Excel/LoadOptions.cs @@ -1,11 +1,10 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { public class LoadOptions { public XLEventTracking EventTracking { get; set; } = XLEventTracking.Enabled; - public Boolean RecalculateAllFormulas { get; set; } = false; + public bool RecalculateAllFormulas { get; set; } } } diff --git a/ClosedXML/Excel/Misc/XLDictionary.cs b/ClosedXML/Excel/Misc/XLDictionary.cs index b386e897b..c89b9befd 100644 --- a/ClosedXML/Excel/Misc/XLDictionary.cs +++ b/ClosedXML/Excel/Misc/XLDictionary.cs @@ -1,11 +1,8 @@ -using System; using System.Collections.Generic; -using System.Linq; -using System.Text; namespace ClosedXML.Excel { - public class XLDictionary: Dictionary + public class XLDictionary: Dictionary { public XLDictionary() { @@ -19,7 +16,9 @@ public XLDictionary(XLDictionary other) public void Initialize(T value) { if (Count > 0) + { Clear(); + } Add(value); } diff --git a/ClosedXML/Excel/Misc/XLFormula.cs b/ClosedXML/Excel/Misc/XLFormula.cs index 80276679c..1175e3276 100644 --- a/ClosedXML/Excel/Misc/XLFormula.cs +++ b/ClosedXML/Excel/Misc/XLFormula.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public class XLFormula @@ -16,7 +11,7 @@ public XLFormula(XLFormula defaultFormula) IsFormula = defaultFormula.IsFormula; } - public XLFormula(String value) + public XLFormula(string value) { Value = value; } @@ -31,28 +26,30 @@ public XLFormula(int value) Value = value.ToInvariantString(); } - internal String _value; - public String Value + internal string _value; + public string Value { get { return _value; } set { if (value == null) { - _value = String.Empty; + _value = string.Empty; } else { _value = value.Trim(); - IsFormula = !String.IsNullOrWhiteSpace(_value) && _value.TrimStart()[0] == '=' ; + IsFormula = !string.IsNullOrWhiteSpace(_value) && _value.TrimStart()[0] == '=' ; if (IsFormula) + { _value = _value.Substring(1); + } } } } - public Boolean IsFormula { get; internal set; } + public bool IsFormula { get; internal set; } } } diff --git a/ClosedXML/Excel/Misc/XLIdManager.cs b/ClosedXML/Excel/Misc/XLIdManager.cs index 7dde3e8e3..8df9ce290 100644 --- a/ClosedXML/Excel/Misc/XLIdManager.cs +++ b/ClosedXML/Excel/Misc/XLIdManager.cs @@ -1,16 +1,13 @@ -using System; using System.Collections.Generic; -using System.Linq; -using System.Text; namespace ClosedXML.Excel { internal class XLIdManager { - private HashSet _hash = new HashSet(); + private readonly HashSet _hash = new HashSet(); - public Int32 GetNext() + public int GetNext() { if (_hash.Count == 0) { @@ -18,7 +15,7 @@ public Int32 GetNext() return 1; } - Int32 id = 1; + var id = 1; while (true) { if (!_hash.Contains(id)) @@ -29,11 +26,11 @@ public Int32 GetNext() id++; } } - public void Add(Int32 value) + public void Add(int value) { _hash.Add(value); } - public void Add(IEnumerable values) + public void Add(IEnumerable values) { values.ForEach(v => _hash.Add(v)); } diff --git a/ClosedXML/Excel/NamedRanges/IXLNamedRange.cs b/ClosedXML/Excel/NamedRanges/IXLNamedRange.cs index 56de92507..42596a568 100644 --- a/ClosedXML/Excel/NamedRanges/IXLNamedRange.cs +++ b/ClosedXML/Excel/NamedRanges/IXLNamedRange.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLNamedRangeScope @@ -18,7 +16,7 @@ public interface IXLNamedRange /// /// The comment for this named range. /// - String Comment { get; set; } + string Comment { get; set; } /// /// Checks if the named range contains invalid references (#REF!). @@ -31,14 +29,14 @@ public interface IXLNamedRange /// /// The name of the range. /// - String Name { get; set; } + string Name { get; set; } /// /// Gets the ranges associated with this named range. /// Note: A named range can point to multiple ranges. /// IXLRanges Ranges { get; } - String RefersTo { get; set; } + string RefersTo { get; set; } /// /// Gets the scope of this named range. @@ -51,7 +49,7 @@ public interface IXLNamedRange /// /// true if visible; otherwise, false. /// - Boolean Visible { get; set; } + bool Visible { get; set; } #endregion Public Properties @@ -63,7 +61,7 @@ public interface IXLNamedRange /// /// Workbook containing the range /// The range address to add. - IXLRanges Add(XLWorkbook workbook, String rangeAddress); + IXLRanges Add(XLWorkbook workbook, string rangeAddress); /// /// Adds the specified range to this named range. @@ -96,7 +94,7 @@ public interface IXLNamedRange /// Note: A named range can point to multiple ranges. /// /// The range address to remove. - void Remove(String rangeAddress); + void Remove(string rangeAddress); /// /// Removes the specified range from this named range. @@ -112,7 +110,7 @@ public interface IXLNamedRange /// The ranges to remove. void Remove(IXLRanges ranges); - IXLNamedRange SetRefersTo(String range); + IXLNamedRange SetRefersTo(string range); IXLNamedRange SetRefersTo(IXLRangeBase range); diff --git a/ClosedXML/Excel/NamedRanges/IXLNamedRanges.cs b/ClosedXML/Excel/NamedRanges/IXLNamedRanges.cs index 3d0eb51a9..55f6edb47 100644 --- a/ClosedXML/Excel/NamedRanges/IXLNamedRanges.cs +++ b/ClosedXML/Excel/NamedRanges/IXLNamedRanges.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -9,7 +8,7 @@ public interface IXLNamedRanges: IEnumerable /// Gets the specified named range. /// /// Name of the range. - IXLNamedRange NamedRange(String rangeName); + IXLNamedRange NamedRange(string rangeName); /// /// Adds a new named range. @@ -17,7 +16,7 @@ public interface IXLNamedRanges: IEnumerable /// Name of the range to add. /// The range address to add. /// - IXLNamedRange Add(String rangeName, String rangeAddress); + IXLNamedRange Add(string rangeName, string rangeAddress); /// /// Adds a new named range. @@ -25,7 +24,7 @@ public interface IXLNamedRanges: IEnumerable /// Name of the range to add. /// The range to add. /// - IXLNamedRange Add(String rangeName, IXLRange range); + IXLNamedRange Add(string rangeName, IXLRange range); /// /// Adds a new named range. @@ -33,7 +32,7 @@ public interface IXLNamedRanges: IEnumerable /// Name of the range to add. /// The ranges to add. /// - IXLNamedRange Add(String rangeName, IXLRanges ranges); + IXLNamedRange Add(string rangeName, IXLRanges ranges); /// /// Adds a new named range. @@ -41,7 +40,7 @@ public interface IXLNamedRanges: IEnumerable /// Name of the ranges to add. /// The range address to add. /// The comment for the new named range. - IXLNamedRange Add(String rangeName, String rangeAddress, String comment); + IXLNamedRange Add(string rangeName, string rangeAddress, string comment); /// /// Adds a new named range. @@ -49,7 +48,7 @@ public interface IXLNamedRanges: IEnumerable /// Name of the ranges to add. /// The range to add. /// The comment for the new named range. - IXLNamedRange Add(String rangeName, IXLRange range, String comment); + IXLNamedRange Add(string rangeName, IXLRange range, string comment); /// /// Adds a new named range. @@ -57,19 +56,19 @@ public interface IXLNamedRanges: IEnumerable /// Name of the ranges to add. /// The ranges to add. /// The comment for the new named range. - IXLNamedRange Add(String rangeName, IXLRanges ranges, String comment); + IXLNamedRange Add(string rangeName, IXLRanges ranges, string comment); /// /// Deletes the specified named range (not the cells). /// /// Name of the range to delete. - void Delete(String rangeName); + void Delete(string rangeName); /// /// Deletes the specified named range's index (not the cells). /// /// Index of the named range to delete. - void Delete(Int32 rangeIndex); + void Delete(int rangeIndex); /// @@ -77,9 +76,9 @@ public interface IXLNamedRanges: IEnumerable /// void DeleteAll(); - Boolean TryGetValue(String name, out IXLNamedRange range); + bool TryGetValue(string name, out IXLNamedRange range); - Boolean Contains(String name); + bool Contains(string name); /// /// Returns a subset of named ranges that do not have invalid references. diff --git a/ClosedXML/Excel/NamedRanges/XLNamedRange.cs b/ClosedXML/Excel/NamedRanges/XLNamedRange.cs index 538fedfe2..ecc7c5b10 100644 --- a/ClosedXML/Excel/NamedRanges/XLNamedRange.cs +++ b/ClosedXML/Excel/NamedRanges/XLNamedRange.cs @@ -1,4 +1,3 @@ -using ClosedXML.Extensions; using System; using System.Collections.Generic; using System.Linq; @@ -7,38 +6,42 @@ namespace ClosedXML.Excel { internal class XLNamedRange : IXLNamedRange { - private String _name; + private string _name; private readonly XLNamedRanges _namedRanges; internal XLWorkbook Workbook => _namedRanges.Workbook; - public XLNamedRange(XLNamedRanges namedRanges, String rangeName, String range, String comment = null) + public XLNamedRange(XLNamedRanges namedRanges, string rangeName, string range, string comment = null) : this(namedRanges, rangeName, validateName: true, range, comment) { } - public XLNamedRange(XLNamedRanges namedRanges, String rangeName, IXLRanges ranges, String comment = null) + public XLNamedRange(XLNamedRanges namedRanges, string rangeName, IXLRanges ranges, string comment = null) : this(namedRanges, rangeName, validateName: true, comment) { ranges.ForEach(r => RangeList.Add(r.RangeAddress.ToStringFixed(XLReferenceStyle.A1, true))); } - internal XLNamedRange(XLNamedRanges namedRanges, String rangeName, Boolean validateName, String range, String comment) + internal XLNamedRange(XLNamedRanges namedRanges, string rangeName, bool validateName, string range, string comment) : this(namedRanges, rangeName, validateName, comment) { //TODO range.Split(',') may produce incorrect result if a worksheet name contains comma. Refactoring needed. range.Split(',').ForEach(r => RangeList.Add(r)); } - internal XLNamedRange(XLNamedRanges namedRanges, String rangeName, Boolean validateName, String comment) + internal XLNamedRange(XLNamedRanges namedRanges, string rangeName, bool validateName, string comment) { _namedRanges = namedRanges ?? throw new ArgumentNullException(nameof(namedRanges)); Visible = true; if (validateName) + { Name = rangeName; + } else + { SetNameWithoutValidation(rangeName); + } Comment = comment; } @@ -46,40 +49,43 @@ internal XLNamedRange(XLNamedRanges namedRanges, String rangeName, Boolean valid /// /// Checks if the named range contains invalid references (#REF!). /// - public bool IsValid - { - get - { - return RangeList.SelectMany(c => c.Split(',')).All(r => - !r.StartsWith("#REF!", StringComparison.OrdinalIgnoreCase) && - !r.EndsWith("#REF!", StringComparison.OrdinalIgnoreCase)); - } - } + public bool IsValid => RangeList.SelectMany(c => c.Split(',')).All(r => + !r.StartsWith("#REF!", StringComparison.OrdinalIgnoreCase) && + !r.EndsWith("#REF!", StringComparison.OrdinalIgnoreCase)); - public String Name + public string Name { get { return _name; } set { - if (_name == value) return; + if (_name == value) + { + return; + } var oldname = _name ?? string.Empty; var existingNames = _namedRanges.Select(nr => nr.Name).ToList(); if (_namedRanges.Scope == XLNamedRangeScope.Workbook) + { existingNames.AddRange(_namedRanges.Workbook.NamedRanges.Select(nr => nr.Name)); + } if (_namedRanges.Scope == XLNamedRangeScope.Worksheet) + { existingNames.AddRange(_namedRanges.Worksheet.NamedRanges.Select(nr => nr.Name)); + } existingNames = existingNames.Distinct().ToList(); - if (!XLHelper.ValidateName("named range", value, oldname, existingNames, out String message)) + if (!XLHelper.ValidateName("named range", value, oldname, existingNames, out var message)) + { throw new ArgumentException(message, nameof(value)); + } _name = value; - if (!String.IsNullOrWhiteSpace(oldname) && !String.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) + if (!string.IsNullOrWhiteSpace(oldname) && !string.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) { _namedRanges.Delete(oldname); _namedRanges.Add(_name, this); @@ -107,19 +113,21 @@ from rangeAddress in RangeList.SelectMany(c => c.Split(',')).Where(s => s[0] != .DataRange?.Column(match.Groups["Column"].Value)) { if (rangeToAdd != null) + { ranges.Add(rangeToAdd); + } } return ranges; } } - public String Comment { get; set; } + public string Comment { get; set; } - public Boolean Visible { get; set; } + public bool Visible { get; set; } - public XLNamedRangeScope Scope { get { return _namedRanges.Scope; } } + public XLNamedRangeScope Scope => _namedRanges.Scope; - public IXLRanges Add(XLWorkbook workbook, String rangeAddress) + public IXLRanges Add(XLWorkbook workbook, string rangeAddress) { var ranges = new XLRanges(); var byExclamation = rangeAddress.Split('!'); @@ -153,7 +161,7 @@ public void Clear() RangeList.Clear(); } - public void Remove(String rangeAddress) + public void Remove(string rangeAddress) { RangeList.Remove(rangeAddress); } @@ -170,12 +178,16 @@ public void Remove(IXLRanges ranges) public override string ToString() { - String retVal = RangeList.Aggregate(String.Empty, (agg, r) => agg + (r + ",")); - if (retVal.Length > 0) retVal = retVal.Substring(0, retVal.Length - 1); + var retVal = RangeList.Aggregate(string.Empty, (agg, r) => agg + r + ","); + if (retVal.Length > 0) + { + retVal = retVal.Substring(0, retVal.Length - 1); + } + return retVal; } - public String RefersTo + public string RefersTo { get { return ToString(); } set @@ -188,24 +200,30 @@ public String RefersTo public IXLNamedRange CopyTo(IXLWorksheet targetSheet) { if (targetSheet == _namedRanges.Worksheet) + { throw new InvalidOperationException("Cannot copy named range to the worksheet it already belongs to."); + } var ranges = new XLRanges(); foreach (var r in Ranges) { if (_namedRanges.Worksheet == r.Worksheet) + { // Named ranges on the source worksheet have to point to the new destination sheet ranges.Add(targetSheet.Range(((XLRangeAddress)r.RangeAddress).WithoutWorksheet())); + } else + { ranges.Add(r); + } } return targetSheet.NamedRanges.Add(Name, ranges); } - internal IList RangeList { get; set; } = new List(); + internal IList RangeList { get; set; } = new List(); - public IXLNamedRange SetRefersTo(String range) + public IXLNamedRange SetRefersTo(string range) { RefersTo = range; return this; @@ -238,4 +256,4 @@ internal void OnWorksheetDeleted(string worksheetName) ).ToList(); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/NamedRanges/XLNamedRanges.cs b/ClosedXML/Excel/NamedRanges/XLNamedRanges.cs index 99b88f84d..7524cec86 100644 --- a/ClosedXML/Excel/NamedRanges/XLNamedRanges.cs +++ b/ClosedXML/Excel/NamedRanges/XLNamedRanges.cs @@ -6,7 +6,7 @@ namespace ClosedXML.Excel { internal class XLNamedRanges : IXLNamedRanges { - private readonly Dictionary _namedRanges = new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly Dictionary _namedRanges = new Dictionary(StringComparer.OrdinalIgnoreCase); internal XLWorkbook Workbook { get; set; } @@ -29,30 +29,32 @@ public XLNamedRanges(XLWorkbook workbook) #region IXLNamedRanges Members - public IXLNamedRange NamedRange(String rangeName) + public IXLNamedRange NamedRange(string rangeName) { - if (_namedRanges.TryGetValue(rangeName, out IXLNamedRange range)) + if (_namedRanges.TryGetValue(rangeName, out var range)) + { return range; + } return null; } - public IXLNamedRange Add(String rangeName, String rangeAddress) + public IXLNamedRange Add(string rangeName, string rangeAddress) { return Add(rangeName, rangeAddress, null); } - public IXLNamedRange Add(String rangeName, IXLRange range) + public IXLNamedRange Add(string rangeName, IXLRange range) { return Add(rangeName, range, null); } - public IXLNamedRange Add(String rangeName, IXLRanges ranges) + public IXLNamedRange Add(string rangeName, IXLRanges ranges) { return Add(rangeName, ranges, null); } - public IXLNamedRange Add(String rangeName, String rangeAddress, String comment) + public IXLNamedRange Add(string rangeName, string rangeAddress, string comment) { return Add(rangeName, rangeAddress, comment, validateName: true, validateRangeAddress: true); } @@ -70,36 +72,43 @@ public IXLNamedRange Add(String rangeName, String rangeAddress, String comment) /// /// For named ranges in the workbook scope, specify the sheet name in the reference. /// - internal IXLNamedRange Add(String rangeName, String rangeAddress, String comment, Boolean validateName, Boolean validateRangeAddress) + internal IXLNamedRange Add(string rangeName, string rangeAddress, string comment, bool validateName, bool validateRangeAddress) { // When loading named ranges from an existing file, we do not validate the range address or name. if (validateRangeAddress) { var match = XLHelper.NamedRangeReferenceRegex.Match(rangeAddress); - if (!match.Success) + if (!match.Success && XLHelper.IsValidRangeAddress(rangeAddress)) { - if (XLHelper.IsValidRangeAddress(rangeAddress)) + IXLRange range; + if (Scope == XLNamedRangeScope.Worksheet) + { + range = Worksheet.Range(rangeAddress); + } + else if (Scope == XLNamedRangeScope.Workbook) + { + range = Workbook.Range(rangeAddress); + } + else + { + throw new NotSupportedException($"Scope {Scope} is not supported"); + } + + if (range == null) + { + throw new ArgumentException(string.Format( + "The range address '{0}' for the named range '{1}' is not a valid range.", rangeAddress, + rangeName)); + } + + if (Scope == XLNamedRangeScope.Workbook || !XLHelper.NamedRangeReferenceRegex.Match(range.ToString()).Success) { - IXLRange range = null; - if (Scope == XLNamedRangeScope.Worksheet) - range = Worksheet.Range(rangeAddress); - else if (Scope == XLNamedRangeScope.Workbook) - range = Workbook.Range(rangeAddress); - else - throw new NotSupportedException($"Scope {Scope} is not supported"); - - if (range == null) - throw new ArgumentException(string.Format( - "The range address '{0}' for the named range '{1}' is not a valid range.", rangeAddress, - rangeName)); - - if (Scope == XLNamedRangeScope.Workbook || !XLHelper.NamedRangeReferenceRegex.Match(range.ToString()).Success) - throw new ArgumentException( - "For named ranges in the workbook scope, specify the sheet name in the reference."); - - rangeAddress = Worksheet.Range(rangeAddress).ToString(); + throw new ArgumentException( + "For named ranges in the workbook scope, specify the sheet name in the reference."); } + + rangeAddress = Worksheet.Range(rangeAddress).ToString(); } } @@ -108,31 +117,31 @@ internal IXLNamedRange Add(String rangeName, String rangeAddress, String comment return namedRange; } - public IXLNamedRange Add(String rangeName, IXLRange range, String comment) + public IXLNamedRange Add(string rangeName, IXLRange range, string comment) { var ranges = new XLRanges { range }; return Add(rangeName, ranges, comment); } - public IXLNamedRange Add(String rangeName, IXLRanges ranges, String comment) + public IXLNamedRange Add(string rangeName, IXLRanges ranges, string comment) { var namedRange = new XLNamedRange(this, rangeName, ranges, comment); _namedRanges.Add(rangeName, namedRange); return namedRange; } - public IXLNamedRange Add(String rangeName, IXLNamedRange namedRange) + public IXLNamedRange Add(string rangeName, IXLNamedRange namedRange) { _namedRanges.Add(rangeName, namedRange); return namedRange; } - public void Delete(String rangeName) + public void Delete(string rangeName) { _namedRanges.Remove(rangeName); } - public void Delete(Int32 rangeIndex) + public void Delete(int rangeIndex) { _namedRanges.Remove(_namedRanges.ElementAt(rangeIndex).Key); } @@ -178,24 +187,36 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() #endregion IEnumerable Members - public Boolean TryGetValue(String name, out IXLNamedRange range) + public bool TryGetValue(string name, out IXLNamedRange range) { - if (_namedRanges.TryGetValue(name, out range)) return true; + if (_namedRanges.TryGetValue(name, out range)) + { + return true; + } if (Scope == XLNamedRangeScope.Workbook) + { range = Workbook.NamedRange(name); + } return range != null; } - public Boolean Contains(String name) + public bool Contains(string name) { - if (_namedRanges.ContainsKey(name)) return true; + if (_namedRanges.ContainsKey(name)) + { + return true; + } if (Scope == XLNamedRangeScope.Workbook) + { return Workbook.NamedRange(name) != null; + } else + { return false; + } } internal void OnWorksheetDeleted(string worksheetName) @@ -205,4 +226,4 @@ internal void OnWorksheetDeleted(string worksheetName) .ForEach(nr => nr.OnWorksheetDeleted(worksheetName)); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PageSetup/IXLHFItem.cs b/ClosedXML/Excel/PageSetup/IXLHFItem.cs index 5f7fc0e7b..416dee996 100644 --- a/ClosedXML/Excel/PageSetup/IXLHFItem.cs +++ b/ClosedXML/Excel/PageSetup/IXLHFItem.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLHFPredefinedText @@ -17,7 +15,7 @@ public interface IXLHFItem: IXLWithRichString /// Gets the text of the specified header/footer occurrence. /// /// The occurrence. - String GetText(XLHFOccurrence occurrence); + string GetText(XLHFOccurrence occurrence); /// /// Adds the given predefined text to this header/footer item. @@ -30,7 +28,7 @@ public interface IXLHFItem: IXLWithRichString /// /// The text to add to this header/footer item. /// The occurrence for the text. - IXLRichString AddText(String text, XLHFOccurrence occurrence); + IXLRichString AddText(string text, XLHFOccurrence occurrence); /// /// Adds the given predefined text to this header/footer item. @@ -43,6 +41,6 @@ public interface IXLHFItem: IXLWithRichString /// The occurrence to clear. void Clear(XLHFOccurrence occurrence = XLHFOccurrence.AllPages); - IXLRichString AddImage(String imagePath, XLHFOccurrence occurrence = XLHFOccurrence.AllPages); + IXLRichString AddImage(string imagePath, XLHFOccurrence occurrence = XLHFOccurrence.AllPages); } } diff --git a/ClosedXML/Excel/PageSetup/IXLHeaderFooter.cs b/ClosedXML/Excel/PageSetup/IXLHeaderFooter.cs index 235875447..8dd50faca 100644 --- a/ClosedXML/Excel/PageSetup/IXLHeaderFooter.cs +++ b/ClosedXML/Excel/PageSetup/IXLHeaderFooter.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLHFMode { OddPagesOnly, OddAndEvenPages, Odd } @@ -24,7 +22,7 @@ public interface IXLHeaderFooter /// Gets the text of the specified header/footer occurrence. /// /// The occurrence. - String GetText(XLHFOccurrence occurrence); + string GetText(XLHFOccurrence occurrence); IXLHeaderFooter Clear(XLHFOccurrence occurrence = XLHFOccurrence.AllPages); } diff --git a/ClosedXML/Excel/PageSetup/IXLMargins.cs b/ClosedXML/Excel/PageSetup/IXLMargins.cs index 148fcfb94..3271fe6cf 100644 --- a/ClosedXML/Excel/PageSetup/IXLMargins.cs +++ b/ClosedXML/Excel/PageSetup/IXLMargins.cs @@ -1,39 +1,37 @@ -using System; - namespace ClosedXML.Excel { public interface IXLMargins { /// Gets or sets the Left margin. /// The Left margin. - Double Left { get; set; } + double Left { get; set; } /// Gets or sets the Right margin. /// The Right margin. - Double Right { get; set; } + double Right { get; set; } /// Gets or sets the Top margin. /// The Top margin. - Double Top { get; set; } + double Top { get; set; } /// Gets or sets the Bottom margin. /// The Bottom margin. - Double Bottom { get; set; } + double Bottom { get; set; } /// Gets or sets the Header margin. /// The Header margin. - Double Header { get; set; } + double Header { get; set; } /// Gets or sets the Footer margin. /// The Footer margin. - Double Footer { get; set; } - - IXLMargins SetLeft(Double value); - IXLMargins SetRight(Double value); - IXLMargins SetTop(Double value); - IXLMargins SetBottom(Double value); - IXLMargins SetHeader(Double value); - IXLMargins SetFooter(Double value); + double Footer { get; set; } + + IXLMargins SetLeft(double value); + IXLMargins SetRight(double value); + IXLMargins SetTop(double value); + IXLMargins SetBottom(double value); + IXLMargins SetHeader(double value); + IXLMargins SetFooter(double value); } } diff --git a/ClosedXML/Excel/PageSetup/IXLPageSetup.cs b/ClosedXML/Excel/PageSetup/IXLPageSetup.cs index d474a70ae..f8a3a6861 100644 --- a/ClosedXML/Excel/PageSetup/IXLPageSetup.cs +++ b/ClosedXML/Excel/PageSetup/IXLPageSetup.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -87,41 +86,41 @@ public interface IXLPageSetup /// Gets the first row that will repeat on the top of the printed pages. /// Use SetRowsToRepeatAtTop() to set the rows that will be repeated on the top of the printed pages. /// - Int32 FirstRowToRepeatAtTop { get; } + int FirstRowToRepeatAtTop { get; } /// /// Gets the last row that will repeat on the top of the printed pages. /// Use SetRowsToRepeatAtTop() to set the rows that will be repeated on the top of the printed pages. /// - Int32 LastRowToRepeatAtTop { get; } + int LastRowToRepeatAtTop { get; } /// /// Sets the rows to repeat on the top of the printed pages. /// /// The range of rows to repeat on the top of the printed pages. - void SetRowsToRepeatAtTop(String range); + void SetRowsToRepeatAtTop(string range); /// /// Sets the rows to repeat on the top of the printed pages. /// /// The first row to repeat at top. /// The last row to repeat at top. - void SetRowsToRepeatAtTop(Int32 firstRowToRepeatAtTop, Int32 lastRowToRepeatAtTop); + void SetRowsToRepeatAtTop(int firstRowToRepeatAtTop, int lastRowToRepeatAtTop); /// Gets the first column to repeat on the left of the printed pages. /// The first column to repeat on the left of the printed pages. - Int32 FirstColumnToRepeatAtLeft { get; } + int FirstColumnToRepeatAtLeft { get; } /// Gets the last column to repeat on the left of the printed pages. /// The last column to repeat on the left of the printed pages. - Int32 LastColumnToRepeatAtLeft { get; } + int LastColumnToRepeatAtLeft { get; } /// /// Sets the rows to repeat on the left of the printed pages. /// /// The first column to repeat at left. /// The last column to repeat at left. - void SetColumnsToRepeatAtLeft(Int32 firstColumnToRepeatAtLeft, Int32 lastColumnToRepeatAtLeft); + void SetColumnsToRepeatAtLeft(int firstColumnToRepeatAtLeft, int lastColumnToRepeatAtLeft); /// /// Sets the rows to repeat on the left of the printed pages. /// /// The range of rows to repeat on the left of the printed pages. - void SetColumnsToRepeatAtLeft(String range); + void SetColumnsToRepeatAtLeft(string range); /// Gets or sets the page orientation for printing. /// The page orientation. @@ -132,54 +131,54 @@ public interface IXLPageSetup /// based on the contents of the worksheet and the PagesWide number. /// Setting this value will override the Scale value. /// - Int32 PagesWide { get; set; } + int PagesWide { get; set; } /// /// Gets or sets the number of pages tall (vertical) the worksheet will be printed on. /// If you don't specify the PagesWide, Excel will adjust that value /// based on the contents of the worksheet and the PagesTall number. /// Setting this value will override the Scale value. /// - Int32 PagesTall { get; set; } + int PagesTall { get; set; } /// /// Gets or sets the scale at which the worksheet will be printed. /// The worksheet will be printed on as many pages as necessary to print at the given scale. /// Setting this value will override the PagesWide and PagesTall values. /// - Int32 Scale { get; set; } + int Scale { get; set; } /// /// Gets or sets the horizontal dpi for printing the worksheet. /// - Int32 HorizontalDpi { get; set; } + int HorizontalDpi { get; set; } /// /// Gets or sets the vertical dpi for printing the worksheet. /// - Int32 VerticalDpi { get; set; } + int VerticalDpi { get; set; } /// /// Gets or sets the page number that will begin the printout. /// For example, the first page of your printout could be numbered page 5. /// - UInt32? FirstPageNumber { get; set; } + uint? FirstPageNumber { get; set; } /// /// Gets or sets a value indicating whether the worksheet will be centered on the page horizontally. /// /// /// true if the worksheet will be centered on the page horizontally; otherwise, false. /// - Boolean CenterHorizontally { get; set; } + bool CenterHorizontally { get; set; } /// /// Gets or sets a value indicating whether the worksheet will be centered on the page vertically. /// /// /// true if the worksheet will be centered on the page vartically; otherwise, false. /// - Boolean CenterVertically { get; set; } + bool CenterVertically { get; set; } /// /// Sets the scale at which the worksheet will be printed. This is equivalent to setting the Scale property. /// The worksheet will be printed on as many pages as necessary to print at the given scale. /// Setting this value will override the PagesWide and PagesTall values. /// /// The scale at which the worksheet will be printed. - void AdjustTo(Int32 percentageOfNormalSize); + void AdjustTo(int percentageOfNormalSize); /// /// Gets or sets the number of pages the worksheet will be printed on. /// This is equivalent to setting both PagesWide and PagesTall properties. @@ -187,7 +186,7 @@ public interface IXLPageSetup /// /// The pages wide. /// The pages tall. - void FitToPages(Int32 pagesWide, Int32 pagesTall); + void FitToPages(int pagesWide, int pagesTall); /// /// Gets or sets the size of the paper to print the worksheet. /// @@ -211,14 +210,14 @@ public interface IXLPageSetup /// /// true if Excel will automatically adjust the font size to the scale of the worksheet; otherwise, false. /// - Boolean ScaleHFWithDocument { get; set; } + bool ScaleHFWithDocument { get; set; } /// /// Gets or sets a value indicating whether the header and footer margins are aligned with the left and right margins of the worksheet. /// /// /// true if the header and footer margins are aligned with the left and right margins of the worksheet; otherwise, false. /// - Boolean AlignHFWithMargins { get; set; } + bool AlignHFWithMargins { get; set; } /// /// Gets or sets a value indicating whether the gridlines will be printed. @@ -226,28 +225,28 @@ public interface IXLPageSetup /// /// true if the gridlines will be printed; otherwise, false. /// - Boolean ShowGridlines { get; set; } + bool ShowGridlines { get; set; } /// /// Gets or sets a value indicating whether to show row numbers and column letters/numbers. /// /// /// true to show row numbers and column letters/numbers; otherwise, false. /// - Boolean ShowRowAndColumnHeadings { get; set; } + bool ShowRowAndColumnHeadings { get; set; } /// /// Gets or sets a value indicating whether the worksheet will be printed in black and white. /// /// /// true if the worksheet will be printed in black and white; otherwise, false. /// - Boolean BlackAndWhite { get; set; } + bool BlackAndWhite { get; set; } /// /// Gets or sets a value indicating whether the worksheet will be printed in draft quality. /// /// /// true if the worksheet will be printed in draft quality; otherwise, false. /// - Boolean DraftQuality { get; set; } + bool DraftQuality { get; set; } /// /// Gets or sets the page order for printing. /// @@ -260,22 +259,22 @@ public interface IXLPageSetup /// /// Gets a list with the row breaks (for printing). /// - List RowBreaks { get; } + List RowBreaks { get; } /// /// Gets a list with the column breaks (for printing). /// - List ColumnBreaks { get; } + List ColumnBreaks { get; } /// /// Adds a horizontal page break after the given row. /// /// The row to insert the break. - void AddHorizontalPageBreak(Int32 row); + void AddHorizontalPageBreak(int row); /// /// Adds a vertical page break after the given column. /// /// The column to insert the break. - void AddVerticalPageBreak(Int32 column); + void AddVerticalPageBreak(int column); /// /// Gets or sets how error values will be printed. @@ -283,29 +282,29 @@ public interface IXLPageSetup XLPrintErrorValues PrintErrorValue { get; set; } IXLPageSetup SetPageOrientation(XLPageOrientation value); - IXLPageSetup SetPagesWide(Int32 value); - IXLPageSetup SetPagesTall(Int32 value); - IXLPageSetup SetScale(Int32 value); - IXLPageSetup SetHorizontalDpi(Int32 value); - IXLPageSetup SetVerticalDpi(Int32 value); - IXLPageSetup SetFirstPageNumber(UInt32? value); - IXLPageSetup SetCenterHorizontally(); IXLPageSetup SetCenterHorizontally(Boolean value); - IXLPageSetup SetCenterVertically(); IXLPageSetup SetCenterVertically(Boolean value); + IXLPageSetup SetPagesWide(int value); + IXLPageSetup SetPagesTall(int value); + IXLPageSetup SetScale(int value); + IXLPageSetup SetHorizontalDpi(int value); + IXLPageSetup SetVerticalDpi(int value); + IXLPageSetup SetFirstPageNumber(uint? value); + IXLPageSetup SetCenterHorizontally(); IXLPageSetup SetCenterHorizontally(bool value); + IXLPageSetup SetCenterVertically(); IXLPageSetup SetCenterVertically(bool value); IXLPageSetup SetPaperSize(XLPaperSize value); - IXLPageSetup SetScaleHFWithDocument(); IXLPageSetup SetScaleHFWithDocument(Boolean value); - IXLPageSetup SetAlignHFWithMargins(); IXLPageSetup SetAlignHFWithMargins(Boolean value); - IXLPageSetup SetShowGridlines(); IXLPageSetup SetShowGridlines(Boolean value); - IXLPageSetup SetShowRowAndColumnHeadings(); IXLPageSetup SetShowRowAndColumnHeadings(Boolean value); - IXLPageSetup SetBlackAndWhite(); IXLPageSetup SetBlackAndWhite(Boolean value); - IXLPageSetup SetDraftQuality(); IXLPageSetup SetDraftQuality(Boolean value); + IXLPageSetup SetScaleHFWithDocument(); IXLPageSetup SetScaleHFWithDocument(bool value); + IXLPageSetup SetAlignHFWithMargins(); IXLPageSetup SetAlignHFWithMargins(bool value); + IXLPageSetup SetShowGridlines(); IXLPageSetup SetShowGridlines(bool value); + IXLPageSetup SetShowRowAndColumnHeadings(); IXLPageSetup SetShowRowAndColumnHeadings(bool value); + IXLPageSetup SetBlackAndWhite(); IXLPageSetup SetBlackAndWhite(bool value); + IXLPageSetup SetDraftQuality(); IXLPageSetup SetDraftQuality(bool value); IXLPageSetup SetPageOrder(XLPageOrderValues value); IXLPageSetup SetShowComments(XLShowCommentsValues value); IXLPageSetup SetPrintErrorValue(XLPrintErrorValues value); - Boolean DifferentFirstPageOnHF { get; set; } - IXLPageSetup SetDifferentFirstPageOnHF(); IXLPageSetup SetDifferentFirstPageOnHF(Boolean value); - Boolean DifferentOddEvenPagesOnHF { get; set; } - IXLPageSetup SetDifferentOddEvenPagesOnHF(); IXLPageSetup SetDifferentOddEvenPagesOnHF(Boolean value); + bool DifferentFirstPageOnHF { get; set; } + IXLPageSetup SetDifferentFirstPageOnHF(); IXLPageSetup SetDifferentFirstPageOnHF(bool value); + bool DifferentOddEvenPagesOnHF { get; set; } + IXLPageSetup SetDifferentOddEvenPagesOnHF(); IXLPageSetup SetDifferentOddEvenPagesOnHF(bool value); } } diff --git a/ClosedXML/Excel/PageSetup/IXLPrintAreas.cs b/ClosedXML/Excel/PageSetup/IXLPrintAreas.cs index 8f04642ad..dc5b3a55a 100644 --- a/ClosedXML/Excel/PageSetup/IXLPrintAreas.cs +++ b/ClosedXML/Excel/PageSetup/IXLPrintAreas.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -13,16 +12,16 @@ public interface IXLPrintAreas: IEnumerable /// The first cell column. /// The last cell row. /// The last cell column. - void Add(Int32 firstCellRow, Int32 firstCellColumn, Int32 lastCellRow, Int32 lastCellColumn); + void Add(int firstCellRow, int firstCellColumn, int lastCellRow, int lastCellColumn); /// Adds a range to the print areas. /// The range address to add. - void Add(String rangeAddress); + void Add(string rangeAddress); /// Adds a range to the print areas. /// The first cell address. /// The last cell address. - void Add(String firstCellAddress, String lastCellAddress); + void Add(string firstCellAddress, string lastCellAddress); /// Adds a range to the print areas. /// The first cell address. diff --git a/ClosedXML/Excel/PageSetup/XLHFItem.cs b/ClosedXML/Excel/PageSetup/XLHFItem.cs index f46500c1a..1215df651 100644 --- a/ClosedXML/Excel/PageSetup/XLHFItem.cs +++ b/ClosedXML/Excel/PageSetup/XLHFItem.cs @@ -1,3 +1,4 @@ +using ClosedXML.Excel.RichText; using System; using System.Collections.Generic; using System.Text; @@ -7,40 +8,46 @@ namespace ClosedXML.Excel internal class XLHFItem : IXLHFItem { internal readonly XLHeaderFooter HeaderFooter; + public XLHFItem(XLHeaderFooter headerFooter) { HeaderFooter = headerFooter; } + public XLHFItem(XLHFItem defaultHFItem, XLHeaderFooter headerFooter) - :this(headerFooter) + : this(headerFooter) { defaultHFItem.texts.ForEach(kp => texts.Add(kp.Key, kp.Value)); } private readonly Dictionary> texts = new Dictionary>(); - public String GetText(XLHFOccurrence occurrence) + + public string GetText(XLHFOccurrence occurrence) { var sb = new StringBuilder(); - if(texts.TryGetValue(occurrence, out List hfTexts)) + if (texts.TryGetValue(occurrence, out var hfTexts)) { foreach (var hfText in hfTexts) + { sb.Append(hfText.GetHFText(sb.ToString())); + } } return sb.ToString(); } - public IXLRichString AddText(String text) + public IXLRichString AddText(string text) { return AddText(text, XLHFOccurrence.AllPages); } + public IXLRichString AddText(XLHFPredefinedText predefinedText) { return AddText(predefinedText, XLHFOccurrence.AllPages); } - public IXLRichString AddText(String text, XLHFOccurrence occurrence) + public IXLRichString AddText(string text, XLHFOccurrence occurrence) { - XLRichString richText = new XLRichString(text, this.HeaderFooter.Worksheet.Style.Font, this); + var richText = new XLRichString(text, HeaderFooter.Worksheet.Style.Font, this); var hfText = new XLHFText(richText, this); if (occurrence == XLHFOccurrence.AllPages) @@ -59,36 +66,40 @@ public IXLRichString AddText(String text, XLHFOccurrence occurrence) public IXLRichString AddNewLine() { - return AddText(Environment.NewLine); + return AddText(XLConstants.NewLine); } - public IXLRichString AddImage(String imagePath, XLHFOccurrence occurrence = XLHFOccurrence.AllPages) + public IXLRichString AddImage(string imagePath, XLHFOccurrence occurrence = XLHFOccurrence.AllPages) { throw new NotImplementedException(); } private void AddTextToOccurrence(XLHFText hfText, XLHFOccurrence occurrence) { - if (texts.TryGetValue(occurrence, out List hfTexts)) + if (texts.TryGetValue(occurrence, out var hfTexts)) + { hfTexts.Add(hfText); + } else + { texts.Add(occurrence, new List { hfText }); + } - this.HeaderFooter.Changed = true; + HeaderFooter.Changed = true; } public IXLRichString AddText(XLHFPredefinedText predefinedText, XLHFOccurrence occurrence) { - String hfText; + string hfText; switch (predefinedText) { case XLHFPredefinedText.PageNumber: hfText = "&P"; break; - case XLHFPredefinedText.NumberOfPages : hfText = "&N"; break; - case XLHFPredefinedText.Date : hfText = "&D"; break; - case XLHFPredefinedText.Time : hfText = "&T"; break; - case XLHFPredefinedText.Path : hfText = "&Z"; break; - case XLHFPredefinedText.File : hfText = "&F"; break; - case XLHFPredefinedText.SheetName : hfText = "&A"; break; + case XLHFPredefinedText.NumberOfPages: hfText = "&N"; break; + case XLHFPredefinedText.Date: hfText = "&D"; break; + case XLHFPredefinedText.Time: hfText = "&T"; break; + case XLHFPredefinedText.Path: hfText = "&Z"; break; + case XLHFPredefinedText.File: hfText = "&F"; break; + case XLHFPredefinedText.SheetName: hfText = "&A"; break; case XLHFPredefinedText.FullPath: hfText = "&Z&F"; break; default: throw new NotImplementedException(); } @@ -112,7 +123,9 @@ public void Clear(XLHFOccurrence occurrence = XLHFOccurrence.AllPages) private void ClearOccurrence(XLHFOccurrence occurrence) { if (texts.ContainsKey(occurrence)) + { texts.Remove(occurrence); + } } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PageSetup/XLHFText.cs b/ClosedXML/Excel/PageSetup/XLHFText.cs index 6659cd67c..b8e6f404d 100644 --- a/ClosedXML/Excel/PageSetup/XLHFText.cs +++ b/ClosedXML/Excel/PageSetup/XLHFText.cs @@ -1,3 +1,4 @@ +using ClosedXML.Excel.RichText; using System; using System.Text; @@ -15,7 +16,7 @@ public XLHFText(XLRichString richText, XLHFItem hfItem) public XLRichString RichText { get; private set; } - public String GetHFText(String prevText) + public string GetHFText(string prevText) { var wsFont = _hfItem.HeaderFooter.Worksheet.Style.Font; @@ -29,44 +30,70 @@ public String GetHFText(String prevText) || !RichText.FontColor.Equals(wsFont.FontColor); if (!isRichText) + { return RichText.Text; + } - StringBuilder sb = new StringBuilder(); + var sb = new StringBuilder(); if (RichText.FontName != null && RichText.FontName != wsFont.FontName) + { sb.Append("&\"" + RichText.FontName); + } else + { sb.Append("&\"-"); + } if (RichText.Bold && RichText.Italic) + { sb.Append(",Bold Italic\""); + } else if (RichText.Bold) + { sb.Append(",Bold\""); + } else if (RichText.Italic) + { sb.Append(",Italic\""); + } else + { sb.Append(",Regular\""); + } if (RichText.FontSize > 0 && Math.Abs(RichText.FontSize - wsFont.FontSize) > XLHelper.Epsilon) + { sb.Append("&" + RichText.FontSize); + } if (RichText.Strikethrough && !wsFont.Strikethrough) + { sb.Append("&S"); + } if (RichText.VerticalAlignment != wsFont.VerticalAlignment) { if (RichText.VerticalAlignment == XLFontVerticalTextAlignmentValues.Subscript) + { sb.Append("&Y"); + } else if (RichText.VerticalAlignment == XLFontVerticalTextAlignmentValues.Superscript) + { sb.Append("&X"); + } } if (RichText.Underline != wsFont.Underline) { if (RichText.Underline == XLFontUnderlineValues.Single) + { sb.Append("&U"); + } else if (RichText.Underline == XLFontUnderlineValues.Double) + { sb.Append("&E"); + } } var lastColorPosition = prevText.LastIndexOf("&K"); @@ -75,28 +102,40 @@ public String GetHFText(String prevText) (lastColorPosition >= 0 && !RichText.FontColor.Equals(XLColor.FromHtml("#" + prevText.Substring(lastColorPosition + 2, 6)))) || (lastColorPosition == -1 && !RichText.FontColor.Equals(wsFont.FontColor)) ) + { sb.Append("&K" + RichText.FontColor.Color.ToHex().Substring(2)); + } sb.Append(RichText.Text); if (RichText.Underline != wsFont.Underline) { if (RichText.Underline == XLFontUnderlineValues.Single) + { sb.Append("&U"); + } else if (RichText.Underline == XLFontUnderlineValues.Double) + { sb.Append("&E"); + } } if (RichText.VerticalAlignment != wsFont.VerticalAlignment) { if (RichText.VerticalAlignment == XLFontVerticalTextAlignmentValues.Subscript) + { sb.Append("&Y"); + } else if (RichText.VerticalAlignment == XLFontVerticalTextAlignmentValues.Superscript) + { sb.Append("&X"); + } } if (RichText.Strikethrough && !wsFont.Strikethrough) + { sb.Append("&S"); + } return sb.ToString(); } diff --git a/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs b/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs index 2290db06d..4e1d7e639 100644 --- a/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs +++ b/ClosedXML/Excel/PageSetup/XLHeaderFooter.cs @@ -1,16 +1,14 @@ using System; using System.Collections.Generic; +using System.Linq; namespace ClosedXML.Excel { - using System.Linq; - - internal class XLHeaderFooter: IXLHeaderFooter + internal class XLHeaderFooter : IXLHeaderFooter { - public XLHeaderFooter(XLWorksheet worksheet) { - this.Worksheet = worksheet; + Worksheet = worksheet; Left = new XLHFItem(this); Right = new XLHFItem(this); Center = new XLHFItem(this); @@ -19,7 +17,7 @@ public XLHeaderFooter(XLWorksheet worksheet) public XLHeaderFooter(XLHeaderFooter defaultHF, XLWorksheet worksheet) { - this.Worksheet = worksheet; + Worksheet = worksheet; defaultHF.innerTexts.ForEach(kp => innerTexts.Add(kp.Key, kp.Value)); Left = new XLHFItem(defaultHF.Left as XLHFItem, this); Center = new XLHFItem(defaultHF.Center as XLHFItem, this); @@ -33,35 +31,45 @@ public XLHeaderFooter(XLHeaderFooter defaultHF, XLWorksheet worksheet) public IXLHFItem Center { get; private set; } public IXLHFItem Right { get; private set; } - public String GetText(XLHFOccurrence occurrence) + public string GetText(XLHFOccurrence occurrence) { //if (innerTexts.ContainsKey(occurrence)) return innerTexts[occurrence]; - var retVal = String.Empty; + var retVal = string.Empty; var leftText = Left.GetText(occurrence); var centerText = Center.GetText(occurrence); var rightText = Right.GetText(occurrence); - retVal += leftText.Length > 0 ? "&L" + leftText : String.Empty; - retVal += centerText.Length > 0 ? "&C" + centerText : String.Empty; - retVal += rightText.Length > 0 ? "&R" + rightText : String.Empty; + retVal += leftText.Length > 0 ? "&L" + leftText : string.Empty; + retVal += centerText.Length > 0 ? "&C" + centerText : string.Empty; + retVal += rightText.Length > 0 ? "&R" + rightText : string.Empty; if (retVal.Length > 255) + { throw new ArgumentOutOfRangeException("Headers and Footers cannot be longer than 255 characters (including style markups)"); + } + return retVal; } - private Dictionary innerTexts = new Dictionary(); - internal void SetInnerText(XLHFOccurrence occurrence, String text) + private readonly Dictionary innerTexts = new Dictionary(); + + internal void SetInnerText(XLHFOccurrence occurrence, string text) { var parsedElements = ParseFormattedHeaderFooterText(text); if (parsedElements.Any(e => e.Position == 'L')) - this.Left.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'L').Select(e => e.Text).ToArray()), occurrence); + { + Left.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'L').Select(e => e.Text).ToArray()), occurrence); + } if (parsedElements.Any(e => e.Position == 'C')) - this.Center.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'C').Select(e => e.Text).ToArray()), occurrence); + { + Center.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'C').Select(e => e.Text).ToArray()), occurrence); + } if (parsedElements.Any(e => e.Position == 'R')) - this.Right.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'R').Select(e => e.Text).ToArray()), occurrence); + { + Right.AddText(string.Join("\r\n", parsedElements.Where(e => e.Position == 'R').Select(e => e.Text).ToArray()), occurrence); + } innerTexts[occurrence] = text; } @@ -74,21 +82,27 @@ private struct ParsedHeaderFooterElement private static IEnumerable ParseFormattedHeaderFooterText(string text) { - Func IsAtPositionIndicator = i => i < text.Length - 1 && text[i] == '&' && (new char[] { 'L', 'C', 'R' }.Contains(text[i + 1])); + bool IsAtPositionIndicator(int i) + { + return i < text.Length - 1 && text[i] == '&' && new[] { 'L', 'C', 'R' }.Contains(text[i + 1]); + } var parsedElements = new List(); var currentPosition = 'L'; // default is LEFT var hfElement = ""; - for (int i = 0; i < text.Length; i++) + for (var i = 0; i < text.Length; i++) { if (IsAtPositionIndicator(i)) { - if ("" != hfElement) parsedElements.Add(new ParsedHeaderFooterElement() + if (!string.IsNullOrEmpty(hfElement)) { - Position = currentPosition, - Text = hfElement - }); + parsedElements.Add(new ParsedHeaderFooterElement() + { + Position = currentPosition, + Text = hfElement + }); + } currentPosition = text[i + 1]; i += 2; @@ -98,25 +112,33 @@ private static IEnumerable ParseFormattedHeaderFooter if (i < text.Length) { if (IsAtPositionIndicator(i)) + { i--; + } else + { hfElement += text[i]; + } } } - if ("" != hfElement) + if (!string.IsNullOrEmpty(hfElement)) + { parsedElements.Add(new ParsedHeaderFooterElement() { Position = currentPosition, Text = hfElement }); + } + return parsedElements; } - private Dictionary _initialTexts; + private Dictionary _initialTexts; - private Boolean _changed; - internal Boolean Changed + private bool _changed; + + internal bool Changed { get { @@ -134,7 +156,6 @@ internal void SetAsInitial() } } - public IXLHeaderFooter Clear(XLHFOccurrence occurrence = XLHFOccurrence.AllPages) { Left.Clear(occurrence); @@ -143,4 +164,4 @@ public IXLHeaderFooter Clear(XLHFOccurrence occurrence = XLHFOccurrence.AllPages return this; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PageSetup/XLMargins.cs b/ClosedXML/Excel/PageSetup/XLMargins.cs index 964354280..1bc78dfc3 100644 --- a/ClosedXML/Excel/PageSetup/XLMargins.cs +++ b/ClosedXML/Excel/PageSetup/XLMargins.cs @@ -1,22 +1,20 @@ -using System; - namespace ClosedXML.Excel { internal class XLMargins: IXLMargins { - public Double Left { get; set; } - public Double Right { get; set; } - public Double Top { get; set; } - public Double Bottom { get; set; } - public Double Header { get; set; } - public Double Footer { get; set; } + public double Left { get; set; } + public double Right { get; set; } + public double Top { get; set; } + public double Bottom { get; set; } + public double Header { get; set; } + public double Footer { get; set; } - public IXLMargins SetLeft(Double value) { Left = value; return this; } - public IXLMargins SetRight(Double value) { Right = value; return this; } - public IXLMargins SetTop(Double value) { Top = value; return this; } - public IXLMargins SetBottom(Double value) { Bottom = value; return this; } - public IXLMargins SetHeader(Double value) { Header = value; return this; } - public IXLMargins SetFooter(Double value) { Footer = value; return this; } + public IXLMargins SetLeft(double value) { Left = value; return this; } + public IXLMargins SetRight(double value) { Right = value; return this; } + public IXLMargins SetTop(double value) { Top = value; return this; } + public IXLMargins SetBottom(double value) { Bottom = value; return this; } + public IXLMargins SetHeader(double value) { Header = value; return this; } + public IXLMargins SetFooter(double value) { Footer = value; return this; } } } diff --git a/ClosedXML/Excel/PageSetup/XLPageSetup.cs b/ClosedXML/Excel/PageSetup/XLPageSetup.cs index ecb54300d..df823d519 100644 --- a/ClosedXML/Excel/PageSetup/XLPageSetup.cs +++ b/ClosedXML/Excel/PageSetup/XLPageSetup.cs @@ -62,46 +62,64 @@ public XLPageSetup(XLPageSetup defaultPageOptions, XLWorksheet worksheet) PrintAreas = new XLPrintAreas(worksheet); Header = new XLHeaderFooter(worksheet); Footer = new XLHeaderFooter(worksheet); - ColumnBreaks = new List(); - RowBreaks = new List(); + ColumnBreaks = new List(); + RowBreaks = new List(); } } public IXLPrintAreas PrintAreas { get; private set; } - public Int32 FirstRowToRepeatAtTop { get; private set; } - public Int32 LastRowToRepeatAtTop { get; private set; } - public void SetRowsToRepeatAtTop(String range) + public int FirstRowToRepeatAtTop { get; private set; } + public int LastRowToRepeatAtTop { get; private set; } + public void SetRowsToRepeatAtTop(string range) { var arrRange = range.Replace("$", "").Split(':'); - SetRowsToRepeatAtTop(Int32.Parse(arrRange[0]), Int32.Parse(arrRange[1])); + SetRowsToRepeatAtTop(int.Parse(arrRange[0]), int.Parse(arrRange[1])); } - public void SetRowsToRepeatAtTop(Int32 firstRowToRepeatAtTop, Int32 lastRowToRepeatAtTop) + public void SetRowsToRepeatAtTop(int firstRowToRepeatAtTop, int lastRowToRepeatAtTop) { - if (firstRowToRepeatAtTop <= 0) throw new ArgumentOutOfRangeException("The first row has to be greater than zero."); - if (firstRowToRepeatAtTop > lastRowToRepeatAtTop) throw new ArgumentOutOfRangeException("The first row has to be less than the second row."); + if (firstRowToRepeatAtTop <= 0) + { + throw new ArgumentOutOfRangeException("The first row has to be greater than zero."); + } + + if (firstRowToRepeatAtTop > lastRowToRepeatAtTop) + { + throw new ArgumentOutOfRangeException("The first row has to be less than the second row."); + } FirstRowToRepeatAtTop = firstRowToRepeatAtTop; LastRowToRepeatAtTop = lastRowToRepeatAtTop; } - public Int32 FirstColumnToRepeatAtLeft { get; private set; } - public Int32 LastColumnToRepeatAtLeft { get; private set; } - public void SetColumnsToRepeatAtLeft(String range) + public int FirstColumnToRepeatAtLeft { get; private set; } + public int LastColumnToRepeatAtLeft { get; private set; } + public void SetColumnsToRepeatAtLeft(string range) { var arrRange = range.Replace("$", "").Split(':'); - if (Int32.TryParse(arrRange[0], out int iTest)) - SetColumnsToRepeatAtLeft(Int32.Parse(arrRange[0]), Int32.Parse(arrRange[1])); + if (int.TryParse(arrRange[0], out var iTest)) + { + SetColumnsToRepeatAtLeft(int.Parse(arrRange[0]), int.Parse(arrRange[1])); + } else + { SetColumnsToRepeatAtLeft(arrRange[0], arrRange[1]); + } } - public void SetColumnsToRepeatAtLeft(String firstColumnToRepeatAtLeft, String lastColumnToRepeatAtLeft) + public void SetColumnsToRepeatAtLeft(string firstColumnToRepeatAtLeft, string lastColumnToRepeatAtLeft) { SetColumnsToRepeatAtLeft(XLHelper.GetColumnNumberFromLetter(firstColumnToRepeatAtLeft), XLHelper.GetColumnNumberFromLetter(lastColumnToRepeatAtLeft)); } - public void SetColumnsToRepeatAtLeft(Int32 firstColumnToRepeatAtLeft, Int32 lastColumnToRepeatAtLeft) + public void SetColumnsToRepeatAtLeft(int firstColumnToRepeatAtLeft, int lastColumnToRepeatAtLeft) { - if (firstColumnToRepeatAtLeft <= 0) throw new ArgumentOutOfRangeException("The first column has to be greater than zero."); - if (firstColumnToRepeatAtLeft > lastColumnToRepeatAtLeft) throw new ArgumentOutOfRangeException("The first column has to be less than the second column."); + if (firstColumnToRepeatAtLeft <= 0) + { + throw new ArgumentOutOfRangeException("The first column has to be greater than zero."); + } + + if (firstColumnToRepeatAtLeft > lastColumnToRepeatAtLeft) + { + throw new ArgumentOutOfRangeException("The first column has to be less than the second column."); + } FirstColumnToRepeatAtLeft = firstColumnToRepeatAtLeft; LastColumnToRepeatAtLeft = lastColumnToRepeatAtLeft; @@ -109,16 +127,16 @@ public void SetColumnsToRepeatAtLeft(Int32 firstColumnToRepeatAtLeft, Int32 last public XLPageOrientation PageOrientation { get; set; } public XLPaperSize PaperSize { get; set; } - public Int32 HorizontalDpi { get; set; } - public Int32 VerticalDpi { get; set; } - public UInt32? FirstPageNumber { get; set; } - public Boolean CenterHorizontally { get; set; } - public Boolean CenterVertically { get; set; } + public int HorizontalDpi { get; set; } + public int VerticalDpi { get; set; } + public uint? FirstPageNumber { get; set; } + public bool CenterHorizontally { get; set; } + public bool CenterVertically { get; set; } public XLPrintErrorValues PrintErrorValue { get; set; } public IXLMargins Margins { get; set; } - private Int32 _pagesWide; - public Int32 PagesWide + private int _pagesWide; + public int PagesWide { get { @@ -128,12 +146,14 @@ public Int32 PagesWide { _pagesWide = value; if (_pagesWide >0) + { _scale = 0; + } } } - private Int32 _pagesTall; - public Int32 PagesTall + private int _pagesTall; + public int PagesTall { get { @@ -143,12 +163,14 @@ public Int32 PagesTall { _pagesTall = value; if (_pagesTall >0) + { _scale = 0; + } } } - private Int32 _scale; - public Int32 Scale + private int _scale; + public int Scale { get { @@ -157,22 +179,26 @@ public Int32 Scale set { _scale = value; - if (_scale <= 0) return; + if (_scale <= 0) + { + return; + } + _pagesTall = 0; _pagesWide = 0; } } - public void AdjustTo(Int32 percentageOfNormalSize) + public void AdjustTo(int percentageOfNormalSize) { Scale = percentageOfNormalSize; _pagesWide = 0; _pagesTall = 0; } - public void FitToPages(Int32 pagesWide, Int32 pagesTall) + public void FitToPages(int pagesWide, int pagesTall) { _pagesWide = pagesWide; - this._pagesTall = pagesTall; + _pagesTall = pagesTall; _scale = 0; } @@ -180,29 +206,35 @@ public void FitToPages(Int32 pagesWide, Int32 pagesTall) public IXLHeaderFooter Header { get; private set; } public IXLHeaderFooter Footer { get; private set; } - public Boolean ScaleHFWithDocument { get; set; } - public Boolean AlignHFWithMargins { get; set; } + public bool ScaleHFWithDocument { get; set; } + public bool AlignHFWithMargins { get; set; } - public Boolean ShowGridlines { get; set; } - public Boolean ShowRowAndColumnHeadings { get; set; } - public Boolean BlackAndWhite { get; set; } - public Boolean DraftQuality { get; set; } + public bool ShowGridlines { get; set; } + public bool ShowRowAndColumnHeadings { get; set; } + public bool BlackAndWhite { get; set; } + public bool DraftQuality { get; set; } public XLPageOrderValues PageOrder { get; set; } public XLShowCommentsValues ShowComments { get; set; } - public List RowBreaks { get; private set; } - public List ColumnBreaks { get; private set; } - public void AddHorizontalPageBreak(Int32 row) + public List RowBreaks { get; private set; } + public List ColumnBreaks { get; private set; } + public void AddHorizontalPageBreak(int row) { if (!RowBreaks.Contains(row)) + { RowBreaks.Add(row); + } + RowBreaks.Sort(); } - public void AddVerticalPageBreak(Int32 column) + public void AddVerticalPageBreak(int column) { if (!ColumnBreaks.Contains(column)) + { ColumnBreaks.Add(column); + } + ColumnBreaks.Sort(); } @@ -219,41 +251,41 @@ public void AddVerticalPageBreak(Int32 column) //} public IXLPageSetup SetPageOrientation(XLPageOrientation value) { PageOrientation = value; return this; } - public IXLPageSetup SetPagesWide(Int32 value) { PagesWide = value; return this; } - public IXLPageSetup SetPagesTall(Int32 value) { PagesTall = value; return this; } - public IXLPageSetup SetScale(Int32 value) { Scale = value; return this; } - public IXLPageSetup SetHorizontalDpi(Int32 value) { HorizontalDpi = value; return this; } - public IXLPageSetup SetVerticalDpi(Int32 value) { VerticalDpi = value; return this; } - public IXLPageSetup SetFirstPageNumber(UInt32? value) { FirstPageNumber = value; return this; } - public IXLPageSetup SetCenterHorizontally() { CenterHorizontally = true; return this; } public IXLPageSetup SetCenterHorizontally(Boolean value) { CenterHorizontally = value; return this; } - public IXLPageSetup SetCenterVertically() { CenterVertically = true; return this; } public IXLPageSetup SetCenterVertically(Boolean value) { CenterVertically = value; return this; } + public IXLPageSetup SetPagesWide(int value) { PagesWide = value; return this; } + public IXLPageSetup SetPagesTall(int value) { PagesTall = value; return this; } + public IXLPageSetup SetScale(int value) { Scale = value; return this; } + public IXLPageSetup SetHorizontalDpi(int value) { HorizontalDpi = value; return this; } + public IXLPageSetup SetVerticalDpi(int value) { VerticalDpi = value; return this; } + public IXLPageSetup SetFirstPageNumber(uint? value) { FirstPageNumber = value; return this; } + public IXLPageSetup SetCenterHorizontally() { CenterHorizontally = true; return this; } public IXLPageSetup SetCenterHorizontally(bool value) { CenterHorizontally = value; return this; } + public IXLPageSetup SetCenterVertically() { CenterVertically = true; return this; } public IXLPageSetup SetCenterVertically(bool value) { CenterVertically = value; return this; } public IXLPageSetup SetPaperSize(XLPaperSize value) { PaperSize = value; return this; } - public IXLPageSetup SetScaleHFWithDocument() { ScaleHFWithDocument = true; return this; } public IXLPageSetup SetScaleHFWithDocument(Boolean value) { ScaleHFWithDocument = value; return this; } - public IXLPageSetup SetAlignHFWithMargins() { AlignHFWithMargins = true; return this; } public IXLPageSetup SetAlignHFWithMargins(Boolean value) { AlignHFWithMargins = value; return this; } - public IXLPageSetup SetShowGridlines() { ShowGridlines = true; return this; } public IXLPageSetup SetShowGridlines(Boolean value) { ShowGridlines = value; return this; } - public IXLPageSetup SetShowRowAndColumnHeadings() { ShowRowAndColumnHeadings = true; return this; } public IXLPageSetup SetShowRowAndColumnHeadings(Boolean value) { ShowRowAndColumnHeadings = value; return this; } - public IXLPageSetup SetBlackAndWhite() { BlackAndWhite = true; return this; } public IXLPageSetup SetBlackAndWhite(Boolean value) { BlackAndWhite = value; return this; } - public IXLPageSetup SetDraftQuality() { DraftQuality = true; return this; } public IXLPageSetup SetDraftQuality(Boolean value) { DraftQuality = value; return this; } + public IXLPageSetup SetScaleHFWithDocument() { ScaleHFWithDocument = true; return this; } public IXLPageSetup SetScaleHFWithDocument(bool value) { ScaleHFWithDocument = value; return this; } + public IXLPageSetup SetAlignHFWithMargins() { AlignHFWithMargins = true; return this; } public IXLPageSetup SetAlignHFWithMargins(bool value) { AlignHFWithMargins = value; return this; } + public IXLPageSetup SetShowGridlines() { ShowGridlines = true; return this; } public IXLPageSetup SetShowGridlines(bool value) { ShowGridlines = value; return this; } + public IXLPageSetup SetShowRowAndColumnHeadings() { ShowRowAndColumnHeadings = true; return this; } public IXLPageSetup SetShowRowAndColumnHeadings(bool value) { ShowRowAndColumnHeadings = value; return this; } + public IXLPageSetup SetBlackAndWhite() { BlackAndWhite = true; return this; } public IXLPageSetup SetBlackAndWhite(bool value) { BlackAndWhite = value; return this; } + public IXLPageSetup SetDraftQuality() { DraftQuality = true; return this; } public IXLPageSetup SetDraftQuality(bool value) { DraftQuality = value; return this; } public IXLPageSetup SetPageOrder(XLPageOrderValues value) { PageOrder = value; return this; } public IXLPageSetup SetShowComments(XLShowCommentsValues value) { ShowComments = value; return this; } public IXLPageSetup SetPrintErrorValue(XLPrintErrorValues value) { PrintErrorValue = value; return this; } - public Boolean DifferentFirstPageOnHF { get; set; } + public bool DifferentFirstPageOnHF { get; set; } public IXLPageSetup SetDifferentFirstPageOnHF() { return SetDifferentFirstPageOnHF(true); } - public IXLPageSetup SetDifferentFirstPageOnHF(Boolean value) + public IXLPageSetup SetDifferentFirstPageOnHF(bool value) { DifferentFirstPageOnHF = value; return this; } - public Boolean DifferentOddEvenPagesOnHF { get; set; } + public bool DifferentOddEvenPagesOnHF { get; set; } public IXLPageSetup SetDifferentOddEvenPagesOnHF() { return SetDifferentOddEvenPagesOnHF(true); } - public IXLPageSetup SetDifferentOddEvenPagesOnHF(Boolean value) + public IXLPageSetup SetDifferentOddEvenPagesOnHF(bool value) { DifferentOddEvenPagesOnHF = value; return this; diff --git a/ClosedXML/Excel/PageSetup/XLPrintAreas.cs b/ClosedXML/Excel/PageSetup/XLPrintAreas.cs index 6aea4b9a2..b4785bd1d 100644 --- a/ClosedXML/Excel/PageSetup/XLPrintAreas.cs +++ b/ClosedXML/Excel/PageSetup/XLPrintAreas.cs @@ -5,8 +5,8 @@ namespace ClosedXML.Excel { internal class XLPrintAreas : IXLPrintAreas { - List ranges = new List(); - private XLWorksheet worksheet; + readonly List ranges = new List(); + private readonly XLWorksheet worksheet; public XLPrintAreas(XLWorksheet worksheet) { this.worksheet = worksheet; diff --git a/ClosedXML/Excel/Patterns/Quadrant.cs b/ClosedXML/Excel/Patterns/Quadrant.cs index 5591ff517..7f0216e7a 100644 --- a/ClosedXML/Excel/Patterns/Quadrant.cs +++ b/ClosedXML/Excel/Patterns/Quadrant.cs @@ -49,10 +49,7 @@ internal class Quadrant /// /// Collection of ranges belonging to this quadrant (does not include ranges from child quadrants). /// - public IEnumerable Ranges - { - get => _ranges?.Values.AsEnumerable(); - } + public IEnumerable Ranges => _ranges?.Values.AsEnumerable(); /// /// The number of current quadrant by horizontal axis. @@ -97,9 +94,9 @@ private Quadrant(byte level, short x, short y) /// True, if range was successfully added, false if it has been added before. public bool Add(IXLAddressable range) { - bool res = false; + var res = false; var children = Children ?? CreateChildren().ToList(); - bool addToChild = false; + var addToChild = false; foreach (var childQuadrant in children) { var rangeAddress = range.RangeAddress; @@ -112,10 +109,14 @@ public bool Add(IXLAddressable range) } if (!addToChild) + { res = AddInternal(range); + } if (Children == null && addToChild) + { Children = children; + } return res; } @@ -128,7 +129,9 @@ public IEnumerable GetAll() if (Ranges != null) { foreach (var range in Ranges) + { yield return range; + } } if (Children != null) @@ -137,7 +140,9 @@ public IEnumerable GetAll() { var childRanges = childQuadrant.GetAll(); foreach (var range in childRanges) + { yield return range; + } } } } @@ -152,7 +157,9 @@ public IEnumerable GetIntersectedRanges(IXLRangeAddress rangeAdd foreach (var range in Ranges) { if (range.RangeAddress.Intersects(rangeAddress)) + { yield return range; + } } } @@ -164,7 +171,9 @@ public IEnumerable GetIntersectedRanges(IXLRangeAddress rangeAdd { var childRanges = childQuadrant.GetIntersectedRanges(rangeAddress); foreach (var range in childRanges) + { yield return range; + } } } } @@ -180,7 +189,9 @@ public IEnumerable GetIntersectedRanges(IXLAddress address) foreach (var range in Ranges) { if (range.RangeAddress.Contains(address)) + { yield return range; + } } } @@ -192,7 +203,9 @@ public IEnumerable GetIntersectedRanges(IXLAddress address) { var childRanges = childQuadrant.GetIntersectedRanges(address); foreach (var range in childRanges) + { yield return range; + } } } } @@ -204,9 +217,9 @@ public IEnumerable GetIntersectedRanges(IXLAddress address) /// True if the range was removed, false if it does not exist in the QuadTree. public bool Remove(IXLRangeAddress rangeAddress) { - bool res = false; + var res = false; - bool coveredByChild = false; + var coveredByChild = false; if (Children != null) { foreach (var childQuadrant in Children) @@ -219,10 +232,9 @@ public bool Remove(IXLRangeAddress rangeAddress) } } - if (!coveredByChild) + if (!coveredByChild && _ranges?.Remove(rangeAddress) == true) { - if (_ranges?.Remove(rangeAddress) == true) - res = true; + res = true; } return res; @@ -253,10 +265,12 @@ public IEnumerable RemoveAll(Predicate predicate if (Children != null) { foreach (var childQuadrant in Children) + { foreach (var childRange in childQuadrant.RemoveAll(predicate)) { yield return childRange; } + } } } @@ -285,10 +299,14 @@ public IEnumerable RemoveAll(Predicate predicate private bool AddInternal(IXLAddressable range) { if (_ranges == null) + { _ranges = new Dictionary(); + } if (_ranges.ContainsKey(range.RangeAddress)) + { return false; + } _ranges.Add(range.RangeAddress, range); return true; @@ -333,11 +351,14 @@ private bool Intersects(in IXLRangeAddress rangeAddress) /// private IEnumerable CreateChildren() { - byte childLevel = (byte)(Level + 1); + var childLevel = (byte)(Level + 1); if (childLevel > MAX_LEVEL) + { yield break; + } + byte xCount = 2; // Always divide on halves - byte yCount = (byte)((Level == 0) ? (XLHelper.MaxRowNumber / XLHelper.MaxColumnNumber) : 2); // Level 0 divide onto 64 parts, the rest - on halves + var yCount = (byte)((Level == 0) ? (XLHelper.MaxRowNumber / XLHelper.MaxColumnNumber) : 2); // Level 0 divide onto 64 parts, the rest - on halves for (byte dy = 0; dy < yCount; dy++) { @@ -355,7 +376,7 @@ private IEnumerable CreateChildren() /// A generic version of /// internal class Quadrant : Quadrant - where T:IXLAddressable + where T : IXLAddressable { public new IEnumerable Ranges => base.Ranges.Cast(); @@ -383,9 +404,10 @@ public bool Remove(T range) { return Remove(range.RangeAddress); } + public IEnumerable RemoveAll(Predicate predicate) { - return base.RemoveAll(r => predicate((T) r)).Cast(); + return base.RemoveAll(r => predicate((T)r)).Cast(); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PivotTables/IXLPivotField.cs b/ClosedXML/Excel/PivotTables/IXLPivotField.cs index 3d588392d..e8a48fd91 100644 --- a/ClosedXML/Excel/PivotTables/IXLPivotField.cs +++ b/ClosedXML/Excel/PivotTables/IXLPivotField.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -24,59 +23,59 @@ public enum XLPivotLayout { Outline, Tabular, Compact } public interface IXLPivotField { - String SourceName { get; } - String CustomName { get; set; } - String SubtotalCaption { get; set; } + string SourceName { get; } + string CustomName { get; set; } + string SubtotalCaption { get; set; } List Subtotals { get; } - Boolean IncludeNewItemsInFilter { get; set; } - - Boolean Outline { get; set; } - Boolean Compact { get; set; } - Boolean? SubtotalsAtTop { get; set; } - Boolean RepeatItemLabels { get; set; } - Boolean InsertBlankLines { get; set; } - Boolean ShowBlankItems { get; set; } - Boolean InsertPageBreaks { get; set; } - Boolean Collapsed { get; set; } + bool IncludeNewItemsInFilter { get; set; } + + bool Outline { get; set; } + bool Compact { get; set; } + bool? SubtotalsAtTop { get; set; } + bool RepeatItemLabels { get; set; } + bool InsertBlankLines { get; set; } + bool ShowBlankItems { get; set; } + bool InsertPageBreaks { get; set; } + bool Collapsed { get; set; } XLPivotSortType SortType { get; set; } - IXLPivotField SetCustomName(String value); + IXLPivotField SetCustomName(string value); - IXLPivotField SetSubtotalCaption(String value); + IXLPivotField SetSubtotalCaption(string value); IXLPivotField AddSubtotal(XLSubtotalFunction value); - IXLPivotField SetIncludeNewItemsInFilter(); IXLPivotField SetIncludeNewItemsInFilter(Boolean value); + IXLPivotField SetIncludeNewItemsInFilter(); IXLPivotField SetIncludeNewItemsInFilter(bool value); IXLPivotField SetLayout(XLPivotLayout value); - IXLPivotField SetSubtotalsAtTop(); IXLPivotField SetSubtotalsAtTop(Boolean value); + IXLPivotField SetSubtotalsAtTop(); IXLPivotField SetSubtotalsAtTop(bool value); - IXLPivotField SetRepeatItemLabels(); IXLPivotField SetRepeatItemLabels(Boolean value); + IXLPivotField SetRepeatItemLabels(); IXLPivotField SetRepeatItemLabels(bool value); - IXLPivotField SetInsertBlankLines(); IXLPivotField SetInsertBlankLines(Boolean value); + IXLPivotField SetInsertBlankLines(); IXLPivotField SetInsertBlankLines(bool value); - IXLPivotField SetShowBlankItems(); IXLPivotField SetShowBlankItems(Boolean value); + IXLPivotField SetShowBlankItems(); IXLPivotField SetShowBlankItems(bool value); - IXLPivotField SetInsertPageBreaks(); IXLPivotField SetInsertPageBreaks(Boolean value); + IXLPivotField SetInsertPageBreaks(); IXLPivotField SetInsertPageBreaks(bool value); - IXLPivotField SetCollapsed(); IXLPivotField SetCollapsed(Boolean value); + IXLPivotField SetCollapsed(); IXLPivotField SetCollapsed(bool value); IXLPivotField SetSort(XLPivotSortType value); - IList SelectedValues { get; } + IList SelectedValues { get; } - IXLPivotField AddSelectedValue(Object value); + IXLPivotField AddSelectedValue(object value); - IXLPivotField AddSelectedValues(IEnumerable values); + IXLPivotField AddSelectedValues(IEnumerable values); IXLPivotFieldStyleFormats StyleFormats { get; } - Boolean IsOnRowAxis { get; } - Boolean IsOnColumnAxis { get; } - Boolean IsInFilterList { get; } + bool IsOnRowAxis { get; } + bool IsOnColumnAxis { get; } + bool IsInFilterList { get; } - Int32 Offset { get; } + int Offset { get; } } } diff --git a/ClosedXML/Excel/PivotTables/IXLPivotFields.cs b/ClosedXML/Excel/PivotTables/IXLPivotFields.cs index 148120dcd..69bea4d6c 100644 --- a/ClosedXML/Excel/PivotTables/IXLPivotFields.cs +++ b/ClosedXML/Excel/PivotTables/IXLPivotFields.cs @@ -1,28 +1,27 @@ // Keep this file CodeMaid organised and cleaned -using System; using System.Collections.Generic; namespace ClosedXML.Excel { public interface IXLPivotFields : IEnumerable { - IXLPivotField Add(String sourceName); + IXLPivotField Add(string sourceName); - IXLPivotField Add(String sourceName, String customName); + IXLPivotField Add(string sourceName, string customName); void Clear(); - Boolean Contains(String sourceName); + bool Contains(string sourceName); - Boolean Contains(IXLPivotField pivotField); + bool Contains(IXLPivotField pivotField); - IXLPivotField Get(String sourceName); + IXLPivotField Get(string sourceName); - IXLPivotField Get(Int32 index); + IXLPivotField Get(int index); - Int32 IndexOf(String sourceName); - Int32 IndexOf(IXLPivotField pf); + int IndexOf(string sourceName); + int IndexOf(IXLPivotField pf); - void Remove(String sourceName); + void Remove(string sourceName); } } diff --git a/ClosedXML/Excel/PivotTables/IXLPivotTable.cs b/ClosedXML/Excel/PivotTables/IXLPivotTable.cs index 8399e00d0..ed927e302 100644 --- a/ClosedXML/Excel/PivotTables/IXLPivotTable.cs +++ b/ClosedXML/Excel/PivotTables/IXLPivotTable.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -122,12 +121,14 @@ public interface IXLPivotTable IXLPivotFields RowLabels { get; } IXLPivotValues Values { get; } - String Name { get; set; } - String Title { get; set; } - String Description { get; set; } + string Name { get; set; } + string Title { get; set; } + string Description { get; set; } + string GrandTotalCaption { get; set; } + string DataCaption { get; set; } - String ColumnHeaderCaption { get; set; } - String RowHeaderCaption { get; set; } + string ColumnHeaderCaption { get; set; } + string RowHeaderCaption { get; set; } IXLCell TargetCell { get; set; } @@ -135,139 +136,138 @@ public interface IXLPivotTable IXLTable SourceTable { get; set; } XLPivotTableSourceType SourceType { get; } - IEnumerable SourceRangeFieldsAvailable { get; } + IEnumerable SourceRangeFieldsAvailable { get; } - Boolean MergeAndCenterWithLabels { get; set; } // MergeItem - Int32 RowLabelIndent { get; set; } // Indent + bool MergeAndCenterWithLabels { get; set; } // MergeItem + int RowLabelIndent { get; set; } // Indent XLFilterAreaOrder FilterAreaOrder { get; set; } // PageOverThenDown - Int32 FilterFieldsPageWrap { get; set; } // PageWrap - String ErrorValueReplacement { get; set; } // ErrorCaption - String EmptyCellReplacement { get; set; } // MissingCaption - Boolean AutofitColumns { get; set; } //UseAutoFormatting - Boolean PreserveCellFormatting { get; set; } // PreserveFormatting - - Boolean ShowGrandTotalsRows { get; set; } // RowGrandTotals - Boolean ShowGrandTotalsColumns { get; set; } // ColumnGrandTotals - Boolean FilteredItemsInSubtotals { get; set; } // Subtotal filtered page items - Boolean AllowMultipleFilters { get; set; } // MultipleFieldFilters - Boolean UseCustomListsForSorting { get; set; } // CustomListSort - - Boolean ShowExpandCollapseButtons { get; set; } - Boolean ShowContextualTooltips { get; set; } - Boolean ShowPropertiesInTooltips { get; set; } - Boolean DisplayCaptionsAndDropdowns { get; set; } - Boolean ClassicPivotTableLayout { get; set; } - Boolean ShowValuesRow { get; set; } - Boolean ShowEmptyItemsOnRows { get; set; } - Boolean ShowEmptyItemsOnColumns { get; set; } - Boolean DisplayItemLabels { get; set; } - Boolean SortFieldsAtoZ { get; set; } - - Boolean PrintExpandCollapsedButtons { get; set; } - Boolean RepeatRowLabels { get; set; } - Boolean PrintTitles { get; set; } - - Boolean SaveSourceData { get; set; } - Boolean EnableShowDetails { get; set; } - Boolean RefreshDataOnOpen { get; set; } + int FilterFieldsPageWrap { get; set; } // PageWrap + string ErrorValueReplacement { get; set; } // ErrorCaption + string EmptyCellReplacement { get; set; } // MissingCaption + bool AutofitColumns { get; set; } //UseAutoFormatting + bool PreserveCellFormatting { get; set; } // PreserveFormatting + + bool ShowGrandTotalsRows { get; set; } // RowGrandTotals + bool ShowGrandTotalsColumns { get; set; } // ColumnGrandTotals + bool FilteredItemsInSubtotals { get; set; } // Subtotal filtered page items + bool AllowMultipleFilters { get; set; } // MultipleFieldFilters + bool UseCustomListsForSorting { get; set; } // CustomListSort + + bool ShowExpandCollapseButtons { get; set; } + bool ShowContextualTooltips { get; set; } + bool ShowPropertiesInTooltips { get; set; } + bool DisplayCaptionsAndDropdowns { get; set; } + bool ClassicPivotTableLayout { get; set; } + bool ShowValuesRow { get; set; } + bool ShowEmptyItemsOnRows { get; set; } + bool ShowEmptyItemsOnColumns { get; set; } + bool DisplayItemLabels { get; set; } + bool SortFieldsAtoZ { get; set; } + + bool PrintExpandCollapsedButtons { get; set; } + bool RepeatRowLabels { get; set; } + bool PrintTitles { get; set; } + + bool SaveSourceData { get; set; } + bool EnableShowDetails { get; set; } + bool RefreshDataOnOpen { get; set; } XLItemsToRetain ItemsToRetainPerField { get; set; } - Boolean EnableCellEditing { get; set; } + bool EnableCellEditing { get; set; } IXLPivotTable CopyTo(IXLCell targetCell); - IXLPivotTable SetName(String value); + IXLPivotTable SetName(string value); - IXLPivotTable SetTitle(String value); + IXLPivotTable SetTitle(string value); - IXLPivotTable SetDescription(String value); + IXLPivotTable SetDescription(string value); + IXLPivotTable SetMergeAndCenterWithLabels(); IXLPivotTable SetMergeAndCenterWithLabels(bool value); - IXLPivotTable SetMergeAndCenterWithLabels(); IXLPivotTable SetMergeAndCenterWithLabels(Boolean value); - - IXLPivotTable SetRowLabelIndent(Int32 value); + IXLPivotTable SetRowLabelIndent(int value); IXLPivotTable SetFilterAreaOrder(XLFilterAreaOrder value); - IXLPivotTable SetFilterFieldsPageWrap(Int32 value); + IXLPivotTable SetFilterFieldsPageWrap(int value); - IXLPivotTable SetErrorValueReplacement(String value); + IXLPivotTable SetErrorValueReplacement(string value); - IXLPivotTable SetEmptyCellReplacement(String value); + IXLPivotTable SetEmptyCellReplacement(string value); - IXLPivotTable SetAutofitColumns(); IXLPivotTable SetAutofitColumns(Boolean value); + IXLPivotTable SetAutofitColumns(); IXLPivotTable SetAutofitColumns(bool value); - IXLPivotTable SetPreserveCellFormatting(); IXLPivotTable SetPreserveCellFormatting(Boolean value); + IXLPivotTable SetPreserveCellFormatting(); IXLPivotTable SetPreserveCellFormatting(bool value); - IXLPivotTable SetShowGrandTotalsRows(); IXLPivotTable SetShowGrandTotalsRows(Boolean value); + IXLPivotTable SetShowGrandTotalsRows(); IXLPivotTable SetShowGrandTotalsRows(bool value); - IXLPivotTable SetShowGrandTotalsColumns(); IXLPivotTable SetShowGrandTotalsColumns(Boolean value); + IXLPivotTable SetShowGrandTotalsColumns(); IXLPivotTable SetShowGrandTotalsColumns(bool value); - IXLPivotTable SetFilteredItemsInSubtotals(); IXLPivotTable SetFilteredItemsInSubtotals(Boolean value); + IXLPivotTable SetFilteredItemsInSubtotals(); IXLPivotTable SetFilteredItemsInSubtotals(bool value); - IXLPivotTable SetAllowMultipleFilters(); IXLPivotTable SetAllowMultipleFilters(Boolean value); + IXLPivotTable SetAllowMultipleFilters(); IXLPivotTable SetAllowMultipleFilters(bool value); - IXLPivotTable SetUseCustomListsForSorting(); IXLPivotTable SetUseCustomListsForSorting(Boolean value); + IXLPivotTable SetUseCustomListsForSorting(); IXLPivotTable SetUseCustomListsForSorting(bool value); - IXLPivotTable SetShowExpandCollapseButtons(); IXLPivotTable SetShowExpandCollapseButtons(Boolean value); + IXLPivotTable SetShowExpandCollapseButtons(); IXLPivotTable SetShowExpandCollapseButtons(bool value); - IXLPivotTable SetShowContextualTooltips(); IXLPivotTable SetShowContextualTooltips(Boolean value); + IXLPivotTable SetShowContextualTooltips(); IXLPivotTable SetShowContextualTooltips(bool value); - IXLPivotTable SetShowPropertiesInTooltips(); IXLPivotTable SetShowPropertiesInTooltips(Boolean value); + IXLPivotTable SetShowPropertiesInTooltips(); IXLPivotTable SetShowPropertiesInTooltips(bool value); - IXLPivotTable SetDisplayCaptionsAndDropdowns(); IXLPivotTable SetDisplayCaptionsAndDropdowns(Boolean value); + IXLPivotTable SetDisplayCaptionsAndDropdowns(); IXLPivotTable SetDisplayCaptionsAndDropdowns(bool value); - IXLPivotTable SetClassicPivotTableLayout(); IXLPivotTable SetClassicPivotTableLayout(Boolean value); + IXLPivotTable SetClassicPivotTableLayout(); IXLPivotTable SetClassicPivotTableLayout(bool value); - IXLPivotTable SetShowValuesRow(); IXLPivotTable SetShowValuesRow(Boolean value); + IXLPivotTable SetShowValuesRow(); IXLPivotTable SetShowValuesRow(bool value); - IXLPivotTable SetShowEmptyItemsOnRows(); IXLPivotTable SetShowEmptyItemsOnRows(Boolean value); + IXLPivotTable SetShowEmptyItemsOnRows(); IXLPivotTable SetShowEmptyItemsOnRows(bool value); - IXLPivotTable SetShowEmptyItemsOnColumns(); IXLPivotTable SetShowEmptyItemsOnColumns(Boolean value); + IXLPivotTable SetShowEmptyItemsOnColumns(); IXLPivotTable SetShowEmptyItemsOnColumns(bool value); - IXLPivotTable SetDisplayItemLabels(); IXLPivotTable SetDisplayItemLabels(Boolean value); + IXLPivotTable SetDisplayItemLabels(); IXLPivotTable SetDisplayItemLabels(bool value); - IXLPivotTable SetSortFieldsAtoZ(); IXLPivotTable SetSortFieldsAtoZ(Boolean value); + IXLPivotTable SetSortFieldsAtoZ(); IXLPivotTable SetSortFieldsAtoZ(bool value); - IXLPivotTable SetPrintExpandCollapsedButtons(); IXLPivotTable SetPrintExpandCollapsedButtons(Boolean value); + IXLPivotTable SetPrintExpandCollapsedButtons(); IXLPivotTable SetPrintExpandCollapsedButtons(bool value); - IXLPivotTable SetRepeatRowLabels(); IXLPivotTable SetRepeatRowLabels(Boolean value); + IXLPivotTable SetRepeatRowLabels(); IXLPivotTable SetRepeatRowLabels(bool value); - IXLPivotTable SetPrintTitles(); IXLPivotTable SetPrintTitles(Boolean value); + IXLPivotTable SetPrintTitles(); IXLPivotTable SetPrintTitles(bool value); - IXLPivotTable SetSaveSourceData(); IXLPivotTable SetSaveSourceData(Boolean value); + IXLPivotTable SetSaveSourceData(); IXLPivotTable SetSaveSourceData(bool value); - IXLPivotTable SetEnableShowDetails(); IXLPivotTable SetEnableShowDetails(Boolean value); + IXLPivotTable SetEnableShowDetails(); IXLPivotTable SetEnableShowDetails(bool value); - IXLPivotTable SetRefreshDataOnOpen(); IXLPivotTable SetRefreshDataOnOpen(Boolean value); + IXLPivotTable SetRefreshDataOnOpen(); IXLPivotTable SetRefreshDataOnOpen(bool value); IXLPivotTable SetItemsToRetainPerField(XLItemsToRetain value); - IXLPivotTable SetEnableCellEditing(); IXLPivotTable SetEnableCellEditing(Boolean value); + IXLPivotTable SetEnableCellEditing(); IXLPivotTable SetEnableCellEditing(bool value); - IXLPivotTable SetColumnHeaderCaption(String value); + IXLPivotTable SetColumnHeaderCaption(string value); - IXLPivotTable SetRowHeaderCaption(String value); + IXLPivotTable SetRowHeaderCaption(string value); - Boolean ShowRowHeaders { get; set; } - Boolean ShowColumnHeaders { get; set; } - Boolean ShowRowStripes { get; set; } - Boolean ShowColumnStripes { get; set; } + bool ShowRowHeaders { get; set; } + bool ShowColumnHeaders { get; set; } + bool ShowRowStripes { get; set; } + bool ShowColumnStripes { get; set; } XLPivotSubtotals Subtotals { get; set; } XLPivotLayout Layout { set; } - Boolean InsertBlankLines { set; } + bool InsertBlankLines { set; } - IXLPivotTable SetShowRowHeaders(); IXLPivotTable SetShowRowHeaders(Boolean value); + IXLPivotTable SetShowRowHeaders(); IXLPivotTable SetShowRowHeaders(bool value); - IXLPivotTable SetShowColumnHeaders(); IXLPivotTable SetShowColumnHeaders(Boolean value); + IXLPivotTable SetShowColumnHeaders(); IXLPivotTable SetShowColumnHeaders(bool value); - IXLPivotTable SetShowRowStripes(); IXLPivotTable SetShowRowStripes(Boolean value); + IXLPivotTable SetShowRowStripes(); IXLPivotTable SetShowRowStripes(bool value); - IXLPivotTable SetShowColumnStripes(); IXLPivotTable SetShowColumnStripes(Boolean value); + IXLPivotTable SetShowColumnStripes(); IXLPivotTable SetShowColumnStripes(bool value); IXLPivotTable SetSubtotals(XLPivotSubtotals value); IXLPivotTable SetLayout(XLPivotLayout value); - IXLPivotTable SetInsertBlankLines(); IXLPivotTable SetInsertBlankLines(Boolean value); + IXLPivotTable SetInsertBlankLines(); IXLPivotTable SetInsertBlankLines(bool value); IXLWorksheet Worksheet { get; } diff --git a/ClosedXML/Excel/PivotTables/IXLPivotTables.cs b/ClosedXML/Excel/PivotTables/IXLPivotTables.cs index 45ca93500..00a287859 100644 --- a/ClosedXML/Excel/PivotTables/IXLPivotTables.cs +++ b/ClosedXML/Excel/PivotTables/IXLPivotTables.cs @@ -5,22 +5,22 @@ namespace ClosedXML.Excel { public interface IXLPivotTables : IEnumerable { - IXLPivotTable Add(String name, IXLCell targetCell, IXLRange range); + IXLPivotTable Add(string name, IXLCell targetCell, IXLRange range); - IXLPivotTable Add(String name, IXLCell targetCell, IXLTable table); + IXLPivotTable Add(string name, IXLCell targetCell, IXLTable table); [Obsolete("Use Add instead")] - IXLPivotTable AddNew(String name, IXLCell targetCell, IXLRange range); + IXLPivotTable AddNew(string name, IXLCell targetCell, IXLRange range); [Obsolete("Use Add instead")] - IXLPivotTable AddNew(String name, IXLCell targetCell, IXLTable table); + IXLPivotTable AddNew(string name, IXLCell targetCell, IXLTable table); - Boolean Contains(String name); + bool Contains(string name); - void Delete(String name); + void Delete(string name); void DeleteAll(); - IXLPivotTable PivotTable(String name); + IXLPivotTable PivotTable(string name); } } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/AbstractPivotFieldReference.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/AbstractPivotFieldReference.cs index e22635c71..00f12204f 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/AbstractPivotFieldReference.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/AbstractPivotFieldReference.cs @@ -1,12 +1,11 @@ using DocumentFormat.OpenXml; -using System; using System.Collections.Generic; namespace ClosedXML.Excel { internal abstract class AbstractPivotFieldReference { - public Boolean DefaultSubtotal { get; set; } + public bool DefaultSubtotal { get; set; } internal abstract UInt32Value GetFieldOffset(); @@ -14,6 +13,6 @@ internal abstract class AbstractPivotFieldReference ///

Helper function used during saving to calculate the indices of the filtered values

/// /// Indices of the filtered values - internal abstract IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt); + internal abstract IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt); } } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/IXLPivotValueStyleFormat.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/IXLPivotValueStyleFormat.cs index c12c71928..044863711 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/IXLPivotValueStyleFormat.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/IXLPivotValueStyleFormat.cs @@ -7,7 +7,7 @@ public interface IXLPivotValueStyleFormat : IXLPivotStyleFormat { IXLPivotValueStyleFormat AndWith(IXLPivotField field); - IXLPivotValueStyleFormat AndWith(IXLPivotField field, Predicate predicate); + IXLPivotValueStyleFormat AndWith(IXLPivotField field, Predicate predicate); IXLPivotValueStyleFormat ForValueField(IXLPivotValue valueField); } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotLabelFieldReference.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotLabelFieldReference.cs index 09570fd72..7da3bd577 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotLabelFieldReference.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotLabelFieldReference.cs @@ -7,15 +7,15 @@ namespace ClosedXML.Excel { internal class PivotLabelFieldReference : AbstractPivotFieldReference { - private readonly Predicate predicate; + private readonly Predicate predicate; public PivotLabelFieldReference(IXLPivotField pivotField) : this(pivotField, null) { } - public PivotLabelFieldReference(IXLPivotField pivotField, Predicate predicate) + public PivotLabelFieldReference(IXLPivotField pivotField, Predicate predicate) { - this.PivotField = pivotField ?? throw new ArgumentNullException(nameof(pivotField)); + PivotField = pivotField ?? throw new ArgumentNullException(nameof(pivotField)); this.predicate = predicate; } @@ -26,12 +26,14 @@ internal override UInt32Value GetFieldOffset() return UInt32Value.FromUInt32((uint)PivotField.Offset); } - internal override IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt) + internal override IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt) { var values = pti.Fields[PivotField.SourceName].DistinctValues.ToList(); if (predicate == null) - return new Int32[] { }; + { + return Array.Empty(); + } return values.Select((Value, Index) => new { Value, Index }) .Where(v => predicate.Invoke(v.Value)) @@ -39,4 +41,4 @@ internal override IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPiv .ToList(); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotValueFieldReference.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotValueFieldReference.cs index 36294467a..a031b03f8 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotValueFieldReference.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/PivotValueFieldReference.cs @@ -1,29 +1,28 @@ using DocumentFormat.OpenXml; -using System; using System.Collections.Generic; namespace ClosedXML.Excel { internal class PivotValueFieldReference : AbstractPivotFieldReference { - public PivotValueFieldReference(String value) + public PivotValueFieldReference(string value) { - this.Value = value; + Value = value; } - public String Value { get; } + public string Value { get; } internal override UInt32Value GetFieldOffset() { return UInt32Value.FromUInt32(unchecked((uint)-2)); } - internal override IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt) + internal override IEnumerable Match(XLWorkbook.PivotTableInfo pti, IXLPivotTable pt) { - return new Int32[] + return new[] { pt.Values.IndexOf(Value.ToString()) }; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotFieldStyleFormats.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotFieldStyleFormats.cs index 4e2840d44..93bdcdba5 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotFieldStyleFormats.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotFieldStyleFormats.cs @@ -11,7 +11,7 @@ internal class XLPivotFieldStyleFormats : IXLPivotFieldStyleFormats public XLPivotFieldStyleFormats(IXLPivotField field) { - this.PivotField = field; + PivotField = field; } public IXLPivotField PivotField { get; } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormat.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormat.cs index 7d05cfb40..232b50601 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormat.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormat.cs @@ -20,7 +20,7 @@ public XLPivotStyleFormat(IXLPivotField field = null, IXLStyle style = null) #endregion IXLPivotStyleFormat members internal XLPivotAreaValues AreaType { get; set; } = XLPivotAreaValues.Normal; - internal bool CollapsedLevelsAreSubtotals { get; set; } = false; + internal bool CollapsedLevelsAreSubtotals { get; set; } internal IList FieldReferences { get; } = new List(); internal bool Outline { get; set; } = true; } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormats.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormats.cs index 3f559fa32..94ae2a3f5 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormats.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotStyleFormats.cs @@ -16,7 +16,7 @@ public XLPivotStyleFormats() public XLPivotStyleFormats(IXLPivotField pivotField) { - this._pivotField = pivotField; + _pivotField = pivotField; } #region IXLPivotStyleFormats members @@ -24,9 +24,11 @@ public XLPivotStyleFormats(IXLPivotField pivotField) public IXLPivotStyleFormat ForElement(XLPivotStyleFormatElement element) { if (element == XLPivotStyleFormatElement.None) + { throw new ArgumentException("Choose an enum value that represents an element", nameof(element)); + } - if (!_styleFormats.TryGetValue(element, out IXLPivotStyleFormat pivotStyleFormat)) + if (!_styleFormats.TryGetValue(element, out var pivotStyleFormat)) { pivotStyleFormat = new XLPivotStyleFormat(_pivotField) { AppliesTo = element }; _styleFormats.Add(element, pivotStyleFormat); @@ -55,7 +57,9 @@ public void Add(IXLPivotStyleFormat styleFormat) public void AddRange(IEnumerable styleFormats) { foreach (var styleFormat in styleFormats) + { Add(styleFormat); + } } } } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotTableStyleFormats.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotTableStyleFormats.cs index 718b650e5..4705668ce 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotTableStyleFormats.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotTableStyleFormats.cs @@ -10,13 +10,13 @@ internal class XLPivotTableStyleFormats : IXLPivotTableStyleFormats public IXLPivotStyleFormats ColumnGrandTotalFormats { - get { return columnGrandTotalFormats ?? (columnGrandTotalFormats = new XLPivotStyleFormats()); } + get { return columnGrandTotalFormats ??= new XLPivotStyleFormats(); } set { columnGrandTotalFormats = value; } } public IXLPivotStyleFormats RowGrandTotalFormats { - get { return rowGrandTotalFormats ?? (rowGrandTotalFormats = new XLPivotStyleFormats()); } + get { return rowGrandTotalFormats ??= new XLPivotStyleFormats(); } set { rowGrandTotalFormats = value; } } diff --git a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotValueStyleFormat.cs b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotValueStyleFormat.cs index 05721c3d7..65cd385bd 100644 --- a/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotValueStyleFormat.cs +++ b/ClosedXML/Excel/PivotTables/PivotStyleFormats/XLPivotValueStyleFormat.cs @@ -16,7 +16,7 @@ public IXLPivotValueStyleFormat AndWith(IXLPivotField field) return AndWith(field, null); } - public IXLPivotValueStyleFormat AndWith(IXLPivotField field, Predicate predicate) + public IXLPivotValueStyleFormat AndWith(IXLPivotField field, Predicate predicate) { FieldReferences.Add(new PivotLabelFieldReference(field, predicate)); return this; diff --git a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValue.cs b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValue.cs index 3723e8236..6391d721b 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValue.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValue.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public enum XLPivotSummary @@ -39,29 +34,29 @@ public enum XLPivotCalculationItem public interface IXLPivotValue { - String SourceName { get; } - String CustomName { get; set; } + string SourceName { get; } + string CustomName { get; set; } IXLPivotValueFormat NumberFormat { get; } XLPivotSummary SummaryFormula { get; set; } XLPivotCalculation Calculation { get; set; } - String BaseField { get; set; } - String BaseItem { get; set; } + string BaseField { get; set; } + string BaseItem { get; set; } XLPivotCalculationItem CalculationItem { get; set; } IXLPivotValue SetSummaryFormula(XLPivotSummary value); IXLPivotValue SetCalculation(XLPivotCalculation value); - IXLPivotValue SetBaseField(String value); - IXLPivotValue SetBaseItem(String value); + IXLPivotValue SetBaseField(string value); + IXLPivotValue SetBaseItem(string value); IXLPivotValue SetCalculationItem(XLPivotCalculationItem value); IXLPivotValue ShowAsNormal(); - IXLPivotValueCombination ShowAsDifferenceFrom(String fieldSourceName); - IXLPivotValueCombination ShowAsPercentageFrom(String fieldSourceName); - IXLPivotValueCombination ShowAsPercentageDifferenceFrom(String fieldSourceName); - IXLPivotValue ShowAsRunningTotalIn(String fieldSourceName); + IXLPivotValueCombination ShowAsDifferenceFrom(string fieldSourceName); + IXLPivotValueCombination ShowAsPercentageFrom(string fieldSourceName); + IXLPivotValueCombination ShowAsPercentageDifferenceFrom(string fieldSourceName); + IXLPivotValue ShowAsRunningTotalIn(string fieldSourceName); IXLPivotValue ShowAsPercentageOfRow(); IXLPivotValue ShowAsPercentageOfColumn(); IXLPivotValue ShowAsPercentageOfTotal(); diff --git a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueCombination.cs b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueCombination.cs index a6e3a72f7..4f36698d9 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueCombination.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueCombination.cs @@ -1,13 +1,8 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { public interface IXLPivotValueCombination { - IXLPivotValue And(String item); + IXLPivotValue And(string item); IXLPivotValue AndPrevious(); IXLPivotValue AndNext(); } diff --git a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueFormat.cs b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueFormat.cs index 2923cb581..2240c483a 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueFormat.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValueFormat.cs @@ -4,8 +4,8 @@ namespace ClosedXML.Excel { public interface IXLPivotValueFormat : IXLNumberFormatBase, IEquatable { - IXLPivotValue SetNumberFormatId(Int32 value); + IXLPivotValue SetNumberFormatId(int value); - IXLPivotValue SetFormat(String value); + IXLPivotValue SetFormat(string value); } } diff --git a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValues.cs b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValues.cs index 68b9c9f16..991ab3134 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValues.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/IXLPivotValues.cs @@ -1,29 +1,28 @@ // Keep this file CodeMaid organised and cleaned -using System; using System.Collections.Generic; namespace ClosedXML.Excel { public interface IXLPivotValues : IEnumerable { - IXLPivotValue Add(String sourceName); + IXLPivotValue Add(string sourceName); - IXLPivotValue Add(String sourceName, String customName); + IXLPivotValue Add(string sourceName, string customName); void Clear(); - Boolean Contains(String sourceName); + bool Contains(string sourceName); - Boolean Contains(IXLPivotValue pivotValue); + bool Contains(IXLPivotValue pivotValue); - IXLPivotValue Get(String sourceName); + IXLPivotValue Get(string sourceName); - IXLPivotValue Get(Int32 index); + IXLPivotValue Get(int index); - Int32 IndexOf(String sourceName); + int IndexOf(string sourceName); - Int32 IndexOf(IXLPivotValue pivotValue); + int IndexOf(IXLPivotValue pivotValue); - void Remove(String sourceName); + void Remove(string sourceName); } } diff --git a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValue.cs b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValue.cs index baed68cd4..d844258e4 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValue.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValue.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLPivotValue: IXLPivotValue @@ -14,13 +9,13 @@ public XLPivotValue(string sourceName) } public IXLPivotValueFormat NumberFormat { get; private set; } - public String SourceName { get; private set; } - public String CustomName { get; set; } public IXLPivotValue SetCustomName(String value) { CustomName = value; return this; } + public string SourceName { get; private set; } + public string CustomName { get; set; } public IXLPivotValue SetCustomName(string value) { CustomName = value; return this; } public XLPivotSummary SummaryFormula { get; set; } public IXLPivotValue SetSummaryFormula(XLPivotSummary value) { SummaryFormula = value; return this; } public XLPivotCalculation Calculation { get; set; } public IXLPivotValue SetCalculation(XLPivotCalculation value) { Calculation = value; return this; } - public String BaseField { get; set; } public IXLPivotValue SetBaseField(String value) { BaseField = value; return this; } - public String BaseItem { get; set; } public IXLPivotValue SetBaseItem(String value) { BaseItem = value; return this; } + public string BaseField { get; set; } public IXLPivotValue SetBaseField(string value) { BaseField = value; return this; } + public string BaseItem { get; set; } public IXLPivotValue SetBaseItem(string value) { BaseItem = value; return this; } public XLPivotCalculationItem CalculationItem { get; set; } public IXLPivotValue SetCalculationItem(XLPivotCalculationItem value) { CalculationItem = value; return this; } @@ -28,25 +23,25 @@ public IXLPivotValue ShowAsNormal() { return SetCalculation(XLPivotCalculation.Normal); } - public IXLPivotValueCombination ShowAsDifferenceFrom(String fieldSourceName) + public IXLPivotValueCombination ShowAsDifferenceFrom(string fieldSourceName) { BaseField = fieldSourceName; SetCalculation(XLPivotCalculation.DifferenceFrom); return new XLPivotValueCombination(this); } - public IXLPivotValueCombination ShowAsPercentageFrom(String fieldSourceName) + public IXLPivotValueCombination ShowAsPercentageFrom(string fieldSourceName) { BaseField = fieldSourceName; SetCalculation(XLPivotCalculation.PercentageOf); return new XLPivotValueCombination(this); } - public IXLPivotValueCombination ShowAsPercentageDifferenceFrom(String fieldSourceName) + public IXLPivotValueCombination ShowAsPercentageDifferenceFrom(string fieldSourceName) { BaseField = fieldSourceName; SetCalculation(XLPivotCalculation.PercentageDifferenceFrom); return new XLPivotValueCombination(this); } - public IXLPivotValue ShowAsRunningTotalIn(String fieldSourceName) + public IXLPivotValue ShowAsRunningTotalIn(string fieldSourceName) { BaseField = fieldSourceName; return SetCalculation(XLPivotCalculation.RunningTotal); diff --git a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueCombination.cs b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueCombination.cs index 5d8c124a9..8820d4a9e 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueCombination.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueCombination.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLPivotValueCombination: IXLPivotValueCombination @@ -12,7 +7,7 @@ public XLPivotValueCombination(IXLPivotValue pivotValue) { _pivotValue = pivotValue; } - public IXLPivotValue And(String item) + public IXLPivotValue And(string item) { _pivotValue.BaseItem = item; _pivotValue.CalculationItem = XLPivotCalculationItem.Value; diff --git a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueFormat.cs b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueFormat.cs index 8ab869be6..2ab655730 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueFormat.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValueFormat.cs @@ -1,8 +1,3 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace ClosedXML.Excel { internal class XLPivotValueFormat: IXLPivotValueFormat @@ -15,8 +10,8 @@ public XLPivotValueFormat(XLPivotValue pivotValue) _numberFormatId = 0; } - private Int32 _numberFormatId = -1; - public Int32 NumberFormatId + private int _numberFormatId = -1; + public int NumberFormatId { get { return _numberFormatId; } set @@ -26,8 +21,8 @@ public Int32 NumberFormatId } } - private String _format = String.Empty; - public String Format + private string _format = string.Empty; + public string Format { get { return _format; } set @@ -37,12 +32,12 @@ public String Format } } - public IXLPivotValue SetNumberFormatId(Int32 value) + public IXLPivotValue SetNumberFormatId(int value) { NumberFormatId = value; return _pivotValue; } - public IXLPivotValue SetFormat(String value) + public IXLPivotValue SetFormat(string value) { Format = value; diff --git a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValues.cs b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValues.cs index 186eb5e3a..53660aa49 100644 --- a/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValues.cs +++ b/ClosedXML/Excel/PivotTables/PivotValues/XLPivotValues.cs @@ -9,28 +9,32 @@ namespace ClosedXML.Excel internal class XLPivotValues : IXLPivotValues { private readonly IXLPivotTable _pivotTable; - private readonly Dictionary _pivotValues = new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly Dictionary _pivotValues = new Dictionary(StringComparer.OrdinalIgnoreCase); internal XLPivotValues(IXLPivotTable pivotTable) { - this._pivotTable = pivotTable; + _pivotTable = pivotTable; } - public IXLPivotValue Add(String sourceName) + public IXLPivotValue Add(string sourceName) { return Add(sourceName, sourceName); } - public IXLPivotValue Add(String sourceName, String customName) + public IXLPivotValue Add(string sourceName, string customName) { - if (sourceName != XLConstants.PivotTable.ValuesSentinalLabel && !this._pivotTable.SourceRangeFieldsAvailable.Contains(sourceName)) - throw new ArgumentOutOfRangeException(nameof(sourceName), String.Format("The column '{0}' does not appear in the source range.", sourceName)); + if (sourceName != XLConstants.PivotTable.ValuesSentinalLabel && !_pivotTable.SourceRangeFieldsAvailable.Contains(sourceName)) + { + throw new ArgumentOutOfRangeException(nameof(sourceName), string.Format("The column '{0}' does not appear in the source range.", sourceName)); + } var pivotValue = new XLPivotValue(sourceName) { CustomName = customName }; _pivotValues.Add(customName, pivotValue); - if (_pivotValues.Count > 1 && this._pivotTable.ColumnLabels.All(cl => cl.SourceName != XLConstants.PivotTable.ValuesSentinalLabel) && this._pivotTable.RowLabels.All(rl => rl.SourceName != XLConstants.PivotTable.ValuesSentinalLabel)) + if (_pivotValues.Count > 1 && _pivotTable.ColumnLabels.All(cl => cl.SourceName != XLConstants.PivotTable.ValuesSentinalLabel) && _pivotTable.RowLabels.All(rl => rl.SourceName != XLConstants.PivotTable.ValuesSentinalLabel)) + { _pivotTable.ColumnLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); + } return pivotValue; } @@ -40,22 +44,22 @@ public void Clear() _pivotValues.Clear(); } - public Boolean Contains(String sourceName) + public bool Contains(string sourceName) { return _pivotValues.ContainsKey(sourceName); } - public Boolean Contains(IXLPivotValue pivotValue) + public bool Contains(IXLPivotValue pivotValue) { return _pivotValues.ContainsKey(pivotValue.SourceName); } - public IXLPivotValue Get(String sourceName) + public IXLPivotValue Get(string sourceName) { return _pivotValues[sourceName]; } - public IXLPivotValue Get(Int32 index) + public IXLPivotValue Get(int index) { return _pivotValues.Values.ElementAt(index); } @@ -70,21 +74,23 @@ IEnumerator IEnumerable.GetEnumerator() return GetEnumerator(); } - public Int32 IndexOf(String sourceName) + public int IndexOf(string sourceName) { var selectedItem = _pivotValues.Select((item, index) => new { Item = item, Position = index }).FirstOrDefault(i => i.Item.Key == sourceName); if (selectedItem == null) + { throw new ArgumentNullException(nameof(sourceName), "Invalid field name."); + } return selectedItem.Position; } - public Int32 IndexOf(IXLPivotValue pivotValue) + public int IndexOf(IXLPivotValue pivotValue) { return IndexOf(pivotValue.SourceName); } - public void Remove(String sourceName) + public void Remove(string sourceName) { _pivotValues.Remove(sourceName); } diff --git a/ClosedXML/Excel/PivotTables/XLPivotField.cs b/ClosedXML/Excel/PivotTables/XLPivotField.cs index 3e9114a8d..baec79ad0 100644 --- a/ClosedXML/Excel/PivotTables/XLPivotField.cs +++ b/ClosedXML/Excel/PivotTables/XLPivotField.cs @@ -1,4 +1,3 @@ -using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; @@ -11,34 +10,34 @@ internal class XLPivotField : IXLPivotField private readonly IXLPivotTable _pivotTable; public XLPivotField(IXLPivotTable pivotTable, string sourceName) { - this._pivotTable = pivotTable; + _pivotTable = pivotTable; SourceName = sourceName; Subtotals = new List(); - SelectedValues = new List(); + SelectedValues = new List(); SortType = XLPivotSortType.Default; SetExcelDefaults(); StyleFormats = new XLPivotFieldStyleFormats(this); } - public String SourceName { get; private set; } - public String CustomName { get; set; } + public string SourceName { get; private set; } + public string CustomName { get; set; } - public IXLPivotField SetCustomName(String value) { CustomName = value; return this; } + public IXLPivotField SetCustomName(string value) { CustomName = value; return this; } - public String SubtotalCaption { get; set; } + public string SubtotalCaption { get; set; } - public IXLPivotField SetSubtotalCaption(String value) { SubtotalCaption = value; return this; } + public IXLPivotField SetSubtotalCaption(string value) { SubtotalCaption = value; return this; } public List Subtotals { get; private set; } public IXLPivotField AddSubtotal(XLSubtotalFunction value) { Subtotals.Add(value); return this; } - public Boolean IncludeNewItemsInFilter { get; set; } + public bool IncludeNewItemsInFilter { get; set; } public IXLPivotField SetIncludeNewItemsInFilter() { IncludeNewItemsInFilter = true; return this; } - public IXLPivotField SetIncludeNewItemsInFilter(Boolean value) { IncludeNewItemsInFilter = value; return this; } + public IXLPivotField SetIncludeNewItemsInFilter(bool value) { IncludeNewItemsInFilter = value; return this; } public bool Outline { get; set; } public bool Compact { get; set; } @@ -55,57 +54,57 @@ public IXLPivotField SetLayout(XLPivotLayout value) return this; } - public Boolean? SubtotalsAtTop { get; set; } + public bool? SubtotalsAtTop { get; set; } public IXLPivotField SetSubtotalsAtTop() { SubtotalsAtTop = true; return this; } - public IXLPivotField SetSubtotalsAtTop(Boolean value) { SubtotalsAtTop = value; return this; } + public IXLPivotField SetSubtotalsAtTop(bool value) { SubtotalsAtTop = value; return this; } - public Boolean RepeatItemLabels { get; set; } + public bool RepeatItemLabels { get; set; } public IXLPivotField SetRepeatItemLabels() { RepeatItemLabels = true; return this; } - public IXLPivotField SetRepeatItemLabels(Boolean value) { RepeatItemLabels = value; return this; } + public IXLPivotField SetRepeatItemLabels(bool value) { RepeatItemLabels = value; return this; } - public Boolean InsertBlankLines { get; set; } + public bool InsertBlankLines { get; set; } public IXLPivotField SetInsertBlankLines() { InsertBlankLines = true; return this; } - public IXLPivotField SetInsertBlankLines(Boolean value) { InsertBlankLines = value; return this; } + public IXLPivotField SetInsertBlankLines(bool value) { InsertBlankLines = value; return this; } - public Boolean ShowBlankItems { get; set; } + public bool ShowBlankItems { get; set; } public IXLPivotField SetShowBlankItems() { ShowBlankItems = true; return this; } - public IXLPivotField SetShowBlankItems(Boolean value) { ShowBlankItems = value; return this; } + public IXLPivotField SetShowBlankItems(bool value) { ShowBlankItems = value; return this; } - public Boolean InsertPageBreaks { get; set; } + public bool InsertPageBreaks { get; set; } public IXLPivotField SetInsertPageBreaks() { InsertPageBreaks = true; return this; } - public IXLPivotField SetInsertPageBreaks(Boolean value) { InsertPageBreaks = value; return this; } + public IXLPivotField SetInsertPageBreaks(bool value) { InsertPageBreaks = value; return this; } - public Boolean Collapsed { get; set; } + public bool Collapsed { get; set; } public IXLPivotField SetCollapsed() { Collapsed = true; return this; } - public IXLPivotField SetCollapsed(Boolean value) { Collapsed = value; return this; } + public IXLPivotField SetCollapsed(bool value) { Collapsed = value; return this; } public XLPivotSortType SortType { get; set; } public IXLPivotField SetSort(XLPivotSortType value) { SortType = value; return this; } - public IList SelectedValues { get; private set; } + public IList SelectedValues { get; private set; } - public IXLPivotField AddSelectedValue(Object value) + public IXLPivotField AddSelectedValue(object value) { SelectedValues.Add(value); return this; } - public IXLPivotField AddSelectedValues(IEnumerable values) + public IXLPivotField AddSelectedValues(IEnumerable values) { - ((List)SelectedValues).AddRange(values); + ((List)SelectedValues).AddRange(values); return this; } @@ -124,12 +123,12 @@ private void SetExcelDefaults() public IXLPivotFieldStyleFormats StyleFormats { get; set; } - public Boolean IsOnRowAxis => _pivotTable.RowLabels.Contains(this.SourceName); + public bool IsOnRowAxis => _pivotTable.RowLabels.Contains(SourceName); - public Boolean IsOnColumnAxis => _pivotTable.ColumnLabels.Contains(this.SourceName); + public bool IsOnColumnAxis => _pivotTable.ColumnLabels.Contains(SourceName); - public Boolean IsInFilterList => _pivotTable.ReportFilters.Contains(this.SourceName); + public bool IsInFilterList => _pivotTable.ReportFilters.Contains(SourceName); - public Int32 Offset => _pivotTable.SourceRangeFieldsAvailable.ToList().IndexOf(this.SourceName); + public int Offset => _pivotTable.SourceRangeFieldsAvailable.ToList().IndexOf(SourceName); } } diff --git a/ClosedXML/Excel/PivotTables/XLPivotFields.cs b/ClosedXML/Excel/PivotTables/XLPivotFields.cs index bc3b07b48..c567f0cfa 100644 --- a/ClosedXML/Excel/PivotTables/XLPivotFields.cs +++ b/ClosedXML/Excel/PivotTables/XLPivotFields.cs @@ -7,25 +7,27 @@ namespace ClosedXML.Excel { internal class XLPivotFields : IXLPivotFields { - private readonly Dictionary _pivotFields = new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly Dictionary _pivotFields = new Dictionary(StringComparer.OrdinalIgnoreCase); private readonly IXLPivotTable _pivotTable; internal XLPivotFields(IXLPivotTable pivotTable) { - this._pivotTable = pivotTable; + _pivotTable = pivotTable; } #region IXLPivotFields members - public IXLPivotField Add(String sourceName) + public IXLPivotField Add(string sourceName) { return Add(sourceName, sourceName); } - public IXLPivotField Add(String sourceName, String customName) + public IXLPivotField Add(string sourceName, string customName) { - if (sourceName != XLConstants.PivotTable.ValuesSentinalLabel && !this._pivotTable.SourceRangeFieldsAvailable.Contains(sourceName)) - throw new ArgumentOutOfRangeException(nameof(sourceName), String.Format("The column '{0}' does not appear in the source range.", sourceName)); + if (sourceName != XLConstants.PivotTable.ValuesSentinalLabel && !_pivotTable.SourceRangeFieldsAvailable.Contains(sourceName)) + { + throw new ArgumentOutOfRangeException(nameof(sourceName), string.Format("The column '{0}' does not appear in the source range.", sourceName)); + } var pivotField = new XLPivotField(_pivotTable, sourceName) { CustomName = customName }; _pivotFields.Add(sourceName, pivotField); @@ -37,7 +39,7 @@ public void Clear() _pivotFields.Clear(); } - public Boolean Contains(String sourceName) + public bool Contains(string sourceName) { return _pivotFields.ContainsKey(sourceName); } @@ -47,12 +49,12 @@ public bool Contains(IXLPivotField pivotField) return _pivotFields.ContainsKey(pivotField.SourceName); } - public IXLPivotField Get(String sourceName) + public IXLPivotField Get(string sourceName) { return _pivotFields[sourceName]; } - public IXLPivotField Get(Int32 index) + public IXLPivotField Get(int index) { return _pivotFields.Values.ElementAt(index); } @@ -67,21 +69,23 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() return GetEnumerator(); } - public Int32 IndexOf(String sourceName) + public int IndexOf(string sourceName) { var selectedItem = _pivotFields.Select((item, index) => new { Item = item, Position = index }).FirstOrDefault(i => i.Item.Key == sourceName); if (selectedItem == null) + { throw new ArgumentNullException(nameof(sourceName), "Invalid field name."); + } return selectedItem.Position; } - public Int32 IndexOf(IXLPivotField pf) + public int IndexOf(IXLPivotField pf) { return IndexOf(pf.SourceName); } - public void Remove(String sourceName) + public void Remove(string sourceName) { _pivotFields.Remove(sourceName); } diff --git a/ClosedXML/Excel/PivotTables/XLPivotTable.cs b/ClosedXML/Excel/PivotTables/XLPivotTable.cs index beef7c88f..aecb6aac7 100644 --- a/ClosedXML/Excel/PivotTables/XLPivotTable.cs +++ b/ClosedXML/Excel/PivotTables/XLPivotTable.cs @@ -9,13 +9,13 @@ namespace ClosedXML.Excel [DebuggerDisplay("{Name}")] internal class XLPivotTable : IXLPivotTable { - private String _name; + private string _name; public Guid Guid { get; private set; } public XLPivotTable(IXLWorksheet worksheet) { - this.Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); - this.Guid = Guid.NewGuid(); + Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); + Guid = Guid.NewGuid(); Fields = new XLPivotFields(this); ReportFilters = new XLPivotFields(this); @@ -37,9 +37,13 @@ public IXLRange SourceRange set { if (value is IXLTable) + { SourceType = XLPivotTableSourceType.Table; + } else + { SourceType = XLPivotTableSourceType.Range; + } sourceRange = value; } @@ -53,10 +57,7 @@ public IXLTable SourceTable public XLPivotTableSourceType SourceType { get; private set; } - public IEnumerable SourceRangeFieldsAvailable - { - get { return this.SourceRange.FirstRow().Cells().Select(c => c.GetString()); } - } + public IEnumerable SourceRangeFieldsAvailable => SourceRange.FirstRow().Cells().Select(c => c.GetString()); public IXLPivotFields Fields { get; private set; } public IXLPivotFields ReportFilters { get; private set; } @@ -69,13 +70,19 @@ public IEnumerable ImplementedFields get { foreach (var pf in ReportFilters) + { yield return pf; + } foreach (var pf in RowLabels) + { yield return pf; + } foreach (var pf in ColumnLabels) + { yield return pf; + } } } @@ -84,25 +91,27 @@ public IEnumerable ImplementedFields public IXLPivotTable CopyTo(IXLCell targetCell) { var addressComparer = new XLAddressComparer(ignoreFixed: true); - if (addressComparer.Equals(targetCell.Address, this.TargetCell.Address)) + if (addressComparer.Equals(targetCell.Address, TargetCell.Address)) + { throw new InvalidOperationException("Cannot copy pivot table to the target cell."); + } var targetSheet = targetCell.Worksheet; - var pivotTableName = this.Name; + var pivotTableName = Name; - int i = 0; + var i = 0; var pivotTableNames = targetSheet.PivotTables.Select(pvt => pvt.Name).ToList(); while (!XLHelper.ValidateName("pivot table", pivotTableName, "", pivotTableNames, out var _)) { i++; - pivotTableName = this.Name + i.ToInvariantString(); + pivotTableName = Name + i.ToInvariantString(); } - var newPivotTable = this.SourceType switch + var newPivotTable = SourceType switch { - XLPivotTableSourceType.Table => targetSheet.PivotTables.Add(pivotTableName, targetCell, this.SourceTable) as XLPivotTable, - XLPivotTableSourceType.Range => targetSheet.PivotTables.Add(pivotTableName, targetCell, this.SourceRange) as XLPivotTable, + XLPivotTableSourceType.Table => targetSheet.PivotTables.Add(pivotTableName, targetCell, SourceTable) as XLPivotTable, + XLPivotTableSourceType.Range => targetSheet.PivotTables.Add(pivotTableName, targetCell, SourceRange) as XLPivotTable, _ => throw new NotImplementedException(), }; @@ -121,19 +130,27 @@ static void copyPivotField(IXLPivotField originalPivotField, IXLPivotField newPi .SetCollapsed(originalPivotField.Collapsed); if (originalPivotField.SubtotalsAtTop.HasValue) + { newPivotField.SetSubtotalsAtTop(originalPivotField.SubtotalsAtTop.Value); + } newPivotField.AddSelectedValues(originalPivotField.SelectedValues); } foreach (var rf in ReportFilters) + { copyPivotField(rf, newPivotTable.ReportFilters.Add(rf.SourceName, rf.CustomName)); + } foreach (var cl in ColumnLabels) + { copyPivotField(cl, newPivotTable.ColumnLabels.Add(cl.SourceName, cl.CustomName)); + } foreach (var rl in RowLabels) + { copyPivotField(rl, newPivotTable.RowLabels.Add(rl.SourceName, rl.CustomName)); + } foreach (var v in Values) { @@ -188,6 +205,8 @@ static void copyPivotField(IXLPivotField originalPivotField, IXLPivotField newPi newPivotTable.ShowRowStripes = ShowRowStripes; newPivotTable.ShowColumnStripes = ShowColumnStripes; newPivotTable.Theme = Theme; + newPivotTable.DataCaption = DataCaption; + newPivotTable.GrandTotalCaption = GrandTotalCaption; // TODO: Copy Styleformats return newPivotTable; @@ -198,21 +217,26 @@ public IXLPivotTable SetTheme(XLPivotTableTheme value) Theme = value; return this; } - public String Name + public string Name { get { return _name; } set { - if (_name == value) return; + if (_name == value) + { + return; + } var oldname = _name ?? string.Empty; - if (!XLHelper.ValidateName("pivot table", value, oldname, Worksheet.PivotTables.Select(pvt => pvt.Name), out String message)) + if (!XLHelper.ValidateName("pivot table", value, oldname, Worksheet.PivotTables.Select(pvt => pvt.Name), out var message)) + { throw new ArgumentException(message, nameof(value)); + } _name = value; - if (!String.IsNullOrWhiteSpace(oldname) && !String.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) + if (!string.IsNullOrWhiteSpace(oldname) && !string.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) { Worksheet.PivotTables.Delete(oldname); (Worksheet.PivotTables as XLPivotTables).Add(_name, this); @@ -220,56 +244,60 @@ public String Name } } - public IXLPivotTable SetName(String value) + public IXLPivotTable SetName(string value) { Name = value; return this; } - public String Title { get; set; } + public string Title { get; set; } - public IXLPivotTable SetTitle(String value) + public IXLPivotTable SetTitle(string value) { Title = value; return this; } - public String Description { get; set; } + public string Description { get; set; } - public IXLPivotTable SetDescription(String value) + public IXLPivotTable SetDescription(string value) { Description = value; return this; } + + public string GrandTotalCaption { get; set; } - public String ColumnHeaderCaption { get; set; } + public string DataCaption { get; set; } - public IXLPivotTable SetColumnHeaderCaption(String value) + public string ColumnHeaderCaption { get; set; } + + public IXLPivotTable SetColumnHeaderCaption(string value) { ColumnHeaderCaption = value; return this; } - public String RowHeaderCaption { get; set; } + public string RowHeaderCaption { get; set; } - public IXLPivotTable SetRowHeaderCaption(String value) + public IXLPivotTable SetRowHeaderCaption(string value) { RowHeaderCaption = value; return this; } - public Boolean MergeAndCenterWithLabels { get; set; } + public bool MergeAndCenterWithLabels { get; set; } public IXLPivotTable SetMergeAndCenterWithLabels() { MergeAndCenterWithLabels = true; return this; } - public IXLPivotTable SetMergeAndCenterWithLabels(Boolean value) + public IXLPivotTable SetMergeAndCenterWithLabels(bool value) { MergeAndCenterWithLabels = value; return this; } - public Int32 RowLabelIndent { get; set; } + public int RowLabelIndent { get; set; } - public IXLPivotTable SetRowLabelIndent(Int32 value) + public IXLPivotTable SetRowLabelIndent(int value) { RowLabelIndent = value; return this; } @@ -281,299 +309,299 @@ public IXLPivotTable SetFilterAreaOrder(XLFilterAreaOrder value) FilterAreaOrder = value; return this; } - public Int32 FilterFieldsPageWrap { get; set; } + public int FilterFieldsPageWrap { get; set; } - public IXLPivotTable SetFilterFieldsPageWrap(Int32 value) + public IXLPivotTable SetFilterFieldsPageWrap(int value) { FilterFieldsPageWrap = value; return this; } - public String ErrorValueReplacement { get; set; } + public string ErrorValueReplacement { get; set; } - public IXLPivotTable SetErrorValueReplacement(String value) + public IXLPivotTable SetErrorValueReplacement(string value) { ErrorValueReplacement = value; return this; } - public String EmptyCellReplacement { get; set; } + public string EmptyCellReplacement { get; set; } - public IXLPivotTable SetEmptyCellReplacement(String value) + public IXLPivotTable SetEmptyCellReplacement(string value) { EmptyCellReplacement = value; return this; } - public Boolean AutofitColumns { get; set; } + public bool AutofitColumns { get; set; } public IXLPivotTable SetAutofitColumns() { AutofitColumns = true; return this; } - public IXLPivotTable SetAutofitColumns(Boolean value) + public IXLPivotTable SetAutofitColumns(bool value) { AutofitColumns = value; return this; } - public Boolean PreserveCellFormatting { get; set; } + public bool PreserveCellFormatting { get; set; } public IXLPivotTable SetPreserveCellFormatting() { PreserveCellFormatting = true; return this; } - public IXLPivotTable SetPreserveCellFormatting(Boolean value) + public IXLPivotTable SetPreserveCellFormatting(bool value) { PreserveCellFormatting = value; return this; } - public Boolean ShowGrandTotalsRows { get; set; } + public bool ShowGrandTotalsRows { get; set; } public IXLPivotTable SetShowGrandTotalsRows() { ShowGrandTotalsRows = true; return this; } - public IXLPivotTable SetShowGrandTotalsRows(Boolean value) + public IXLPivotTable SetShowGrandTotalsRows(bool value) { ShowGrandTotalsRows = value; return this; } - public Boolean ShowGrandTotalsColumns { get; set; } + public bool ShowGrandTotalsColumns { get; set; } public IXLPivotTable SetShowGrandTotalsColumns() { ShowGrandTotalsColumns = true; return this; } - public IXLPivotTable SetShowGrandTotalsColumns(Boolean value) + public IXLPivotTable SetShowGrandTotalsColumns(bool value) { ShowGrandTotalsColumns = value; return this; } - public Boolean FilteredItemsInSubtotals { get; set; } + public bool FilteredItemsInSubtotals { get; set; } public IXLPivotTable SetFilteredItemsInSubtotals() { FilteredItemsInSubtotals = true; return this; } - public IXLPivotTable SetFilteredItemsInSubtotals(Boolean value) + public IXLPivotTable SetFilteredItemsInSubtotals(bool value) { FilteredItemsInSubtotals = value; return this; } - public Boolean AllowMultipleFilters { get; set; } + public bool AllowMultipleFilters { get; set; } public IXLPivotTable SetAllowMultipleFilters() { AllowMultipleFilters = true; return this; } - public IXLPivotTable SetAllowMultipleFilters(Boolean value) + public IXLPivotTable SetAllowMultipleFilters(bool value) { AllowMultipleFilters = value; return this; } - public Boolean UseCustomListsForSorting { get; set; } + public bool UseCustomListsForSorting { get; set; } public IXLPivotTable SetUseCustomListsForSorting() { UseCustomListsForSorting = true; return this; } - public IXLPivotTable SetUseCustomListsForSorting(Boolean value) + public IXLPivotTable SetUseCustomListsForSorting(bool value) { UseCustomListsForSorting = value; return this; } - public Boolean ShowExpandCollapseButtons { get; set; } + public bool ShowExpandCollapseButtons { get; set; } public IXLPivotTable SetShowExpandCollapseButtons() { ShowExpandCollapseButtons = true; return this; } - public IXLPivotTable SetShowExpandCollapseButtons(Boolean value) + public IXLPivotTable SetShowExpandCollapseButtons(bool value) { ShowExpandCollapseButtons = value; return this; } - public Boolean ShowContextualTooltips { get; set; } + public bool ShowContextualTooltips { get; set; } public IXLPivotTable SetShowContextualTooltips() { ShowContextualTooltips = true; return this; } - public IXLPivotTable SetShowContextualTooltips(Boolean value) + public IXLPivotTable SetShowContextualTooltips(bool value) { ShowContextualTooltips = value; return this; } - public Boolean ShowPropertiesInTooltips { get; set; } + public bool ShowPropertiesInTooltips { get; set; } public IXLPivotTable SetShowPropertiesInTooltips() { ShowPropertiesInTooltips = true; return this; } - public IXLPivotTable SetShowPropertiesInTooltips(Boolean value) + public IXLPivotTable SetShowPropertiesInTooltips(bool value) { ShowPropertiesInTooltips = value; return this; } - public Boolean DisplayCaptionsAndDropdowns { get; set; } + public bool DisplayCaptionsAndDropdowns { get; set; } public IXLPivotTable SetDisplayCaptionsAndDropdowns() { DisplayCaptionsAndDropdowns = true; return this; } - public IXLPivotTable SetDisplayCaptionsAndDropdowns(Boolean value) + public IXLPivotTable SetDisplayCaptionsAndDropdowns(bool value) { DisplayCaptionsAndDropdowns = value; return this; } - public Boolean ClassicPivotTableLayout { get; set; } + public bool ClassicPivotTableLayout { get; set; } public IXLPivotTable SetClassicPivotTableLayout() { ClassicPivotTableLayout = true; return this; } - public IXLPivotTable SetClassicPivotTableLayout(Boolean value) + public IXLPivotTable SetClassicPivotTableLayout(bool value) { ClassicPivotTableLayout = value; return this; } - public Boolean ShowValuesRow { get; set; } + public bool ShowValuesRow { get; set; } public IXLPivotTable SetShowValuesRow() { ShowValuesRow = true; return this; } - public IXLPivotTable SetShowValuesRow(Boolean value) + public IXLPivotTable SetShowValuesRow(bool value) { ShowValuesRow = value; return this; } - public Boolean ShowEmptyItemsOnRows { get; set; } + public bool ShowEmptyItemsOnRows { get; set; } public IXLPivotTable SetShowEmptyItemsOnRows() { ShowEmptyItemsOnRows = true; return this; } - public IXLPivotTable SetShowEmptyItemsOnRows(Boolean value) + public IXLPivotTable SetShowEmptyItemsOnRows(bool value) { ShowEmptyItemsOnRows = value; return this; } - public Boolean ShowEmptyItemsOnColumns { get; set; } + public bool ShowEmptyItemsOnColumns { get; set; } public IXLPivotTable SetShowEmptyItemsOnColumns() { ShowEmptyItemsOnColumns = true; return this; } - public IXLPivotTable SetShowEmptyItemsOnColumns(Boolean value) + public IXLPivotTable SetShowEmptyItemsOnColumns(bool value) { ShowEmptyItemsOnColumns = value; return this; } - public Boolean DisplayItemLabels { get; set; } + public bool DisplayItemLabels { get; set; } public IXLPivotTable SetDisplayItemLabels() { DisplayItemLabels = true; return this; } - public IXLPivotTable SetDisplayItemLabels(Boolean value) + public IXLPivotTable SetDisplayItemLabels(bool value) { DisplayItemLabels = value; return this; } - public Boolean SortFieldsAtoZ { get; set; } + public bool SortFieldsAtoZ { get; set; } public IXLPivotTable SetSortFieldsAtoZ() { SortFieldsAtoZ = true; return this; } - public IXLPivotTable SetSortFieldsAtoZ(Boolean value) + public IXLPivotTable SetSortFieldsAtoZ(bool value) { SortFieldsAtoZ = value; return this; } - public Boolean PrintExpandCollapsedButtons { get; set; } + public bool PrintExpandCollapsedButtons { get; set; } public IXLPivotTable SetPrintExpandCollapsedButtons() { PrintExpandCollapsedButtons = true; return this; } - public IXLPivotTable SetPrintExpandCollapsedButtons(Boolean value) + public IXLPivotTable SetPrintExpandCollapsedButtons(bool value) { PrintExpandCollapsedButtons = value; return this; } - public Boolean RepeatRowLabels { get; set; } + public bool RepeatRowLabels { get; set; } public IXLPivotTable SetRepeatRowLabels() { RepeatRowLabels = true; return this; } - public IXLPivotTable SetRepeatRowLabels(Boolean value) + public IXLPivotTable SetRepeatRowLabels(bool value) { RepeatRowLabels = value; return this; } - public Boolean PrintTitles { get; set; } + public bool PrintTitles { get; set; } public IXLPivotTable SetPrintTitles() { PrintTitles = true; return this; } - public IXLPivotTable SetPrintTitles(Boolean value) + public IXLPivotTable SetPrintTitles(bool value) { PrintTitles = value; return this; } - public Boolean SaveSourceData { get; set; } + public bool SaveSourceData { get; set; } public IXLPivotTable SetSaveSourceData() { SaveSourceData = true; return this; } - public IXLPivotTable SetSaveSourceData(Boolean value) + public IXLPivotTable SetSaveSourceData(bool value) { SaveSourceData = value; return this; } - public Boolean EnableShowDetails { get; set; } + public bool EnableShowDetails { get; set; } public IXLPivotTable SetEnableShowDetails() { EnableShowDetails = true; return this; } - public IXLPivotTable SetEnableShowDetails(Boolean value) + public IXLPivotTable SetEnableShowDetails(bool value) { EnableShowDetails = value; return this; } - public Boolean RefreshDataOnOpen { get; set; } + public bool RefreshDataOnOpen { get; set; } public IXLPivotTable SetRefreshDataOnOpen() { RefreshDataOnOpen = true; return this; } - public IXLPivotTable SetRefreshDataOnOpen(Boolean value) + public IXLPivotTable SetRefreshDataOnOpen(bool value) { RefreshDataOnOpen = value; return this; } @@ -585,62 +613,62 @@ public IXLPivotTable SetItemsToRetainPerField(XLItemsToRetain value) ItemsToRetainPerField = value; return this; } - public Boolean EnableCellEditing { get; set; } + public bool EnableCellEditing { get; set; } public IXLPivotTable SetEnableCellEditing() { EnableCellEditing = true; return this; } - public IXLPivotTable SetEnableCellEditing(Boolean value) + public IXLPivotTable SetEnableCellEditing(bool value) { EnableCellEditing = value; return this; } - public Boolean ShowRowHeaders { get; set; } + public bool ShowRowHeaders { get; set; } public IXLPivotTable SetShowRowHeaders() { ShowRowHeaders = true; return this; } - public IXLPivotTable SetShowRowHeaders(Boolean value) + public IXLPivotTable SetShowRowHeaders(bool value) { ShowRowHeaders = value; return this; } - public Boolean ShowColumnHeaders { get; set; } + public bool ShowColumnHeaders { get; set; } public IXLPivotTable SetShowColumnHeaders() { ShowColumnHeaders = true; return this; } - public IXLPivotTable SetShowColumnHeaders(Boolean value) + public IXLPivotTable SetShowColumnHeaders(bool value) { ShowColumnHeaders = value; return this; } - public Boolean ShowRowStripes { get; set; } + public bool ShowRowStripes { get; set; } public IXLPivotTable SetShowRowStripes() { ShowRowStripes = true; return this; } - public IXLPivotTable SetShowRowStripes(Boolean value) + public IXLPivotTable SetShowRowStripes(bool value) { ShowRowStripes = value; return this; } - public Boolean ShowColumnStripes { get; set; } + public bool ShowColumnStripes { get; set; } public IXLPivotTable SetShowColumnStripes() { ShowColumnStripes = true; return this; } - public IXLPivotTable SetShowColumnStripes(Boolean value) + public IXLPivotTable SetShowColumnStripes(bool value) { ShowColumnStripes = value; return this; } @@ -662,7 +690,7 @@ public IXLPivotTable SetLayout(XLPivotLayout value) Layout = value; return this; } - public Boolean InsertBlankLines + public bool InsertBlankLines { set { Fields.ForEach(f => f.SetInsertBlankLines(value)); } } @@ -672,18 +700,18 @@ public IXLPivotTable SetInsertBlankLines() InsertBlankLines = true; return this; } - public IXLPivotTable SetInsertBlankLines(Boolean value) + public IXLPivotTable SetInsertBlankLines(bool value) { InsertBlankLines = value; return this; } - internal String RelId { get; set; } - internal String CacheDefinitionRelId { get; set; } - internal String WorkbookCacheRelId { get; set; } + internal string RelId { get; set; } + internal string CacheDefinitionRelId { get; set; } + internal string WorkbookCacheRelId { get; set; } private void SetExcelDefaults() { - EmptyCellReplacement = String.Empty; + EmptyCellReplacement = string.Empty; SaveSourceData = true; ShowColumnHeaders = true; ShowRowHeaders = true; @@ -722,11 +750,15 @@ public IEnumerable AllStyleFormats { get { - foreach (var styleFormat in this.StyleFormats.RowGrandTotalFormats) + foreach (var styleFormat in StyleFormats.RowGrandTotalFormats) + { yield return styleFormat; + } - foreach (var styleFormat in this.StyleFormats.ColumnGrandTotalFormats) + foreach (var styleFormat in StyleFormats.ColumnGrandTotalFormats) + { yield return styleFormat; + } foreach (var pivotField in ImplementedFields) { diff --git a/ClosedXML/Excel/PivotTables/XLPivotTables.cs b/ClosedXML/Excel/PivotTables/XLPivotTables.cs index a601d5829..cc860b260 100644 --- a/ClosedXML/Excel/PivotTables/XLPivotTables.cs +++ b/ClosedXML/Excel/PivotTables/XLPivotTables.cs @@ -6,21 +6,21 @@ namespace ClosedXML.Excel { internal class XLPivotTables : IXLPivotTables { - private readonly Dictionary _pivotTables = new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly Dictionary _pivotTables = new Dictionary(StringComparer.OrdinalIgnoreCase); public XLPivotTables(IXLWorksheet worksheet) { - this.Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); + Worksheet = worksheet ?? throw new ArgumentNullException(nameof(worksheet)); } - internal void Add(String name, IXLPivotTable pivotTable) + internal void Add(string name, IXLPivotTable pivotTable) { _pivotTables.Add(name, (XLPivotTable)pivotTable); } public IXLPivotTable Add(string name, IXLCell targetCell, IXLRange range) { - var pivotTable = new XLPivotTable(this.Worksheet) + var pivotTable = new XLPivotTable(Worksheet) { Name = name, TargetCell = targetCell, @@ -32,7 +32,7 @@ public IXLPivotTable Add(string name, IXLCell targetCell, IXLRange range) public IXLPivotTable Add(string name, IXLCell targetCell, IXLTable table) { - var pivotTable = new XLPivotTable(this.Worksheet) + var pivotTable = new XLPivotTable(Worksheet) { Name = name, TargetCell = targetCell, @@ -52,12 +52,12 @@ public IXLPivotTable AddNew(string name, IXLCell targetCell, IXLTable table) return Add(name, targetCell, table); } - public Boolean Contains(String name) + public bool Contains(string name) { return _pivotTables.ContainsKey(name); } - public void Delete(String name) + public void Delete(string name) { _pivotTables.Remove(name); } @@ -77,12 +77,12 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() return GetEnumerator(); } - public XLPivotTable PivotTable(String name) + public XLPivotTable PivotTable(string name) { return _pivotTables[name]; } - IXLPivotTable IXLPivotTables.PivotTable(String name) + IXLPivotTable IXLPivotTables.PivotTable(string name) { return PivotTable(name); } diff --git a/ClosedXML/Excel/Protection/IXLElementProtection.cs b/ClosedXML/Excel/Protection/IXLElementProtection.cs index 754ffa515..4ad855f67 100644 --- a/ClosedXML/Excel/Protection/IXLElementProtection.cs +++ b/ClosedXML/Excel/Protection/IXLElementProtection.cs @@ -18,7 +18,7 @@ public interface IXLElementProtection : IXLElementProtection /// The element to add /// Set to true to allow the element or false to disallow the element /// The current protection instance - IXLElementProtection AllowElement(T element, Boolean allowed = true); + IXLElementProtection AllowElement(T element, bool allowed = true); /// Allows all elements to be edited. /// @@ -49,7 +49,7 @@ public interface IXLElementProtection : IXLElementProtection /// The password. /// The algorithm. /// - IXLElementProtection Protect(String password, Algorithm algorithm = DefaultProtectionAlgorithm); + IXLElementProtection Protect(string password, Algorithm algorithm = DefaultProtectionAlgorithm); /// Unprotects this instance without a password. /// @@ -58,7 +58,7 @@ public interface IXLElementProtection : IXLElementProtection /// Unprotects this instance using the specified password. /// The password. /// - IXLElementProtection Unprotect(String password); + IXLElementProtection Unprotect(string password); } public interface IXLElementProtection : ICloneable @@ -71,12 +71,12 @@ public interface IXLElementProtection : ICloneable /// /// true if this instance is password protected; otherwise, false. /// - Boolean IsPasswordProtected { get; } + bool IsPasswordProtected { get; } /// Gets a value indicating whether this instance is protected, either with or without a password. /// /// true if this instance is protected; otherwise, false. /// - Boolean IsProtected { get; } + bool IsProtected { get; } } } diff --git a/ClosedXML/Excel/Protection/IXLProtectable.cs b/ClosedXML/Excel/Protection/IXLProtectable.cs index f253c36e2..e49275e82 100644 --- a/ClosedXML/Excel/Protection/IXLProtectable.cs +++ b/ClosedXML/Excel/Protection/IXLProtectable.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; using static ClosedXML.Excel.XLProtectionAlgorithm; namespace ClosedXML.Excel @@ -18,14 +17,14 @@ public interface IXLProtectable : IXLProtectable /// The password. /// The algorithm. /// - new TProtection Protect(String password, Algorithm algorithm = DefaultProtectionAlgorithm); + new TProtection Protect(string password, Algorithm algorithm = DefaultProtectionAlgorithm); /// Protects this instance with the specified password, password hash algorithm and set elements that the user is allowed to change. /// The password. /// The algorithm. /// The allowed elements. /// - TProtection Protect(String password, Algorithm algorithm, TElement allowedElements); + TProtection Protect(string password, Algorithm algorithm, TElement allowedElements); /// Unprotects this instance without a password. /// @@ -34,7 +33,7 @@ public interface IXLProtectable : IXLProtectable /// Unprotects this instance using the specified password. /// The password. /// - new TProtection Unprotect(String password); + new TProtection Unprotect(string password); } public interface IXLProtectable @@ -43,13 +42,13 @@ public interface IXLProtectable /// /// true if this instance is password protected; otherwise, false. /// - Boolean IsPasswordProtected { get; } + bool IsPasswordProtected { get; } /// Gets a value indicating whether this instance is protected, either with or without a password. /// /// true if this instance is protected; otherwise, false. /// - Boolean IsProtected { get; } + bool IsProtected { get; } /// Protects this instance without a password. /// @@ -59,7 +58,7 @@ public interface IXLProtectable /// The password. /// The algorithm. /// - IXLElementProtection Protect(String password, Algorithm algorithm = DefaultProtectionAlgorithm); + IXLElementProtection Protect(string password, Algorithm algorithm = DefaultProtectionAlgorithm); /// Unprotects this instance without a password. /// @@ -68,6 +67,6 @@ public interface IXLProtectable /// Unprotects this instance using the specified password. /// The password. /// - IXLElementProtection Unprotect(String password); + IXLElementProtection Unprotect(string password); } } diff --git a/ClosedXML/Excel/Protection/XLSheetProtection.cs b/ClosedXML/Excel/Protection/XLSheetProtection.cs index e58d6c69d..5bf39a11b 100644 --- a/ClosedXML/Excel/Protection/XLSheetProtection.cs +++ b/ClosedXML/Excel/Protection/XLSheetProtection.cs @@ -8,24 +8,26 @@ internal class XLSheetProtection : IXLSheetProtection { public XLSheetProtection(Algorithm algorithm) { - this.Algorithm = algorithm; + Algorithm = algorithm; AllowedElements = XLSheetProtectionElements.SelectEverything; } public Algorithm Algorithm { get; internal set; } public XLSheetProtectionElements AllowedElements { get; set; } - public Boolean IsPasswordProtected => this.IsProtected && !String.IsNullOrEmpty(PasswordHash); - public Boolean IsProtected { get; internal set; } + public bool IsPasswordProtected => IsProtected && !string.IsNullOrEmpty(PasswordHash); + public bool IsProtected { get; internal set; } - internal String Base64EncodedSalt { get; set; } - internal String PasswordHash { get; set; } - internal UInt32 SpinCount { get; set; } = 100000; + internal string Base64EncodedSalt { get; set; } + internal string PasswordHash { get; set; } + internal uint SpinCount { get; set; } = 100000; - public IXLSheetProtection AllowElement(XLSheetProtectionElements element, Boolean allowed = true) + public IXLSheetProtection AllowElement(XLSheetProtectionElements element, bool allowed = true) { if (!allowed) + { return DisallowElement(element); + } AllowedElements |= element; return this; @@ -44,13 +46,13 @@ public IXLSheetProtection AllowNone() public object Clone() { - return new XLSheetProtection(this.Algorithm) + return new XLSheetProtection(Algorithm) { - IsProtected = this.IsProtected, - PasswordHash = this.PasswordHash, - SpinCount = this.SpinCount, - Base64EncodedSalt = this.Base64EncodedSalt, - AllowedElements = this.AllowedElements + IsProtected = IsProtected, + PasswordHash = PasswordHash, + SpinCount = SpinCount, + Base64EncodedSalt = Base64EncodedSalt, + AllowedElements = AllowedElements }; } @@ -58,12 +60,12 @@ public XLSheetProtection CopyFrom(IXLElementProtection IXLElementProtection.AllowElement(XLSheetProtectionElements element, Boolean allowed) => AllowElement(element, allowed); + IXLElementProtection IXLElementProtection.AllowElement(XLSheetProtectionElements element, bool allowed) => AllowElement(element, allowed); IXLElementProtection IXLElementProtection.AllowEverything() => AllowEverything(); @@ -143,11 +149,11 @@ public IXLSheetProtection Unprotect(String password) IXLElementProtection IXLElementProtection.Protect() => Protect(); - IXLElementProtection IXLElementProtection.Protect(String password, Algorithm algorithm) => Protect(password, algorithm); + IXLElementProtection IXLElementProtection.Protect(string password, Algorithm algorithm) => Protect(password, algorithm); IXLElementProtection IXLElementProtection.Unprotect() => Unprotect(); - IXLElementProtection IXLElementProtection.Unprotect(String password) => Unprotect(password); + IXLElementProtection IXLElementProtection.Unprotect(string password) => Unprotect(password); #endregion IXLProtectable interface } diff --git a/ClosedXML/Excel/Protection/XLWorkbookProtection.cs b/ClosedXML/Excel/Protection/XLWorkbookProtection.cs index 886ee1bcb..c9be9f734 100644 --- a/ClosedXML/Excel/Protection/XLWorkbookProtection.cs +++ b/ClosedXML/Excel/Protection/XLWorkbookProtection.cs @@ -13,25 +13,29 @@ public XLWorkbookProtection(Algorithm algorithm) public XLWorkbookProtection(Algorithm algorithm, XLWorkbookProtectionElements allowedElements) { - this.Algorithm = algorithm; - this.AllowedElements = allowedElements; + Algorithm = algorithm; + AllowedElements = allowedElements; } public Algorithm Algorithm { get; internal set; } public XLWorkbookProtectionElements AllowedElements { get; set; } - public bool IsPasswordProtected => this.IsProtected && !String.IsNullOrEmpty(PasswordHash); + public bool IsPasswordProtected => IsProtected && !string.IsNullOrEmpty(PasswordHash); public bool IsProtected { get; internal set; } - internal String Base64EncodedSalt { get; set; } - internal String PasswordHash { get; set; } - internal UInt32 SpinCount { get; set; } = 100000; + internal string Base64EncodedSalt { get; set; } + internal string PasswordHash { get; set; } + internal uint SpinCount { get; set; } = 100000; - public IXLWorkbookProtection AllowElement(XLWorkbookProtectionElements element, Boolean allowed = true) + public IXLWorkbookProtection AllowElement(XLWorkbookProtectionElements element, bool allowed = true) { if (allowed) + { AllowedElements |= element; + } else + { AllowedElements &= ~element; + } return this; } @@ -50,12 +54,12 @@ public IXLWorkbookProtection AllowNone() public object Clone() { - return new XLWorkbookProtection(this.Algorithm, this.AllowedElements) + return new XLWorkbookProtection(Algorithm, AllowedElements) { - IsProtected = this.IsProtected, - PasswordHash = this.PasswordHash, - SpinCount = this.SpinCount, - Base64EncodedSalt = this.Base64EncodedSalt + IsProtected = IsProtected, + PasswordHash = PasswordHash, + SpinCount = SpinCount, + Base64EncodedSalt = Base64EncodedSalt }; } @@ -63,12 +67,12 @@ public IXLWorkbookProtection CopyFrom(IXLElementProtection IXLElementProtection.AllowElement(XLWorkbookProtectionElements element, Boolean allowed) => AllowElement(element, allowed); + IXLElementProtection IXLElementProtection.AllowElement(XLWorkbookProtectionElements element, bool allowed) => AllowElement(element, allowed); IXLElementProtection IXLElementProtection.AllowEverything() => AllowEverything(); @@ -145,11 +153,11 @@ public IXLWorkbookProtection Unprotect(String password) IXLElementProtection IXLElementProtection.Protect() => Protect(); - IXLElementProtection IXLElementProtection.Protect(String password, Algorithm algorithm) => Protect(password, algorithm); + IXLElementProtection IXLElementProtection.Protect(string password, Algorithm algorithm) => Protect(password, algorithm); IXLElementProtection IXLElementProtection.Unprotect() => Unprotect(); - IXLElementProtection IXLElementProtection.Unprotect(String password) => Unprotect(password); + IXLElementProtection IXLElementProtection.Unprotect(string password) => Unprotect(password); IXLElementProtection IXLElementProtection.CopyFrom(IXLElementProtection protectable) => CopyFrom(protectable); diff --git a/ClosedXML/Excel/Ranges/IXLBaseCollection.cs b/ClosedXML/Excel/Ranges/IXLBaseCollection.cs index d4d6c83e8..5467b237f 100644 --- a/ClosedXML/Excel/Ranges/IXLBaseCollection.cs +++ b/ClosedXML/Excel/Ranges/IXLBaseCollection.cs @@ -1,11 +1,10 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel { public interface IXLBaseCollection : IEnumerable { - Int32 Count { get; } + int Count { get; } IXLStyle Style { get; set; } @@ -17,7 +16,7 @@ public interface IXLBaseCollection : IEnumerable /// The default scope for the named range is Workbook. /// /// Name of the range. - TMultiple AddToNamed(String rangeName); + TMultiple AddToNamed(string rangeName); /// /// Creates a named range out of these ranges. @@ -25,7 +24,7 @@ public interface IXLBaseCollection : IEnumerable /// Name of the range. /// The scope for the named range. /// - TMultiple AddToNamed(String rangeName, XLScope scope); + TMultiple AddToNamed(string rangeName, XLScope scope); /// /// Creates a named range out of these ranges. @@ -34,7 +33,7 @@ public interface IXLBaseCollection : IEnumerable /// The scope for the named range. /// The comments for the named range. /// - TMultiple AddToNamed(String rangeName, XLScope scope, String comment); + TMultiple AddToNamed(string rangeName, XLScope scope, string comment); /// /// Sets the cells' value. @@ -46,7 +45,7 @@ public interface IXLBaseCollection : IEnumerable /// /// The object containing the value(s) to set. /// - Object Value { set; } + object Value { set; } TMultiple SetValue(T value); @@ -64,7 +63,7 @@ public interface IXLBaseCollection : IEnumerable /// Returns the collection of cells that have a value. /// /// if set to true will return all cells with a value or a style different than the default. - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); TMultiple SetDataType(XLDataType dataType); diff --git a/ClosedXML/Excel/Ranges/IXLRange.cs b/ClosedXML/Excel/Ranges/IXLRange.cs index 527a8ceb5..55ac94e73 100644 --- a/ClosedXML/Excel/Ranges/IXLRange.cs +++ b/ClosedXML/Excel/Ranges/IXLRange.cs @@ -52,37 +52,37 @@ public interface IXLRange : IXLRangeBase /// /// Gets the first column of the range. /// - IXLRangeColumn FirstColumn(Func predicate = null); + IXLRangeColumn FirstColumn(Func predicate = null); /// /// Gets the first column of the range that contains a cell with a value. /// [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn FirstColumnUsed(Boolean includeFormats, Func predicate = null); + IXLRangeColumn FirstColumnUsed(bool includeFormats, Func predicate = null); - IXLRangeColumn FirstColumnUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeColumn FirstColumnUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeColumn FirstColumnUsed(Func predicate = null); + IXLRangeColumn FirstColumnUsed(Func predicate = null); /// /// Gets the last column of the range. /// - IXLRangeColumn LastColumn(Func predicate = null); + IXLRangeColumn LastColumn(Func predicate = null); /// /// Gets the last column of the range that contains a cell with a value. /// [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn LastColumnUsed(Boolean includeFormats, Func predicate = null); + IXLRangeColumn LastColumnUsed(bool includeFormats, Func predicate = null); - IXLRangeColumn LastColumnUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeColumn LastColumnUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeColumn LastColumnUsed(Func predicate = null); + IXLRangeColumn LastColumnUsed(Func predicate = null); /// /// Gets a collection of all columns in this range. /// - IXLRangeColumns Columns(Func predicate = null); + IXLRangeColumns Columns(Func predicate = null); /// /// Gets a collection of the specified columns in this range. @@ -109,42 +109,42 @@ public interface IXLRange : IXLRangeBase /// /// Returns the first row that matches the given predicate /// - IXLRangeColumn FindColumn(Func predicate); + IXLRangeColumn FindColumn(Func predicate); /// /// Returns the first row that matches the given predicate /// - IXLRangeRow FindRow(Func predicate); + IXLRangeRow FindRow(Func predicate); /// /// Gets the first row of the range. /// - IXLRangeRow FirstRow(Func predicate = null); + IXLRangeRow FirstRow(Func predicate = null); /// /// Gets the first row of the range that contains a cell with a value. /// [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow FirstRowUsed(Boolean includeFormats, Func predicate = null); + IXLRangeRow FirstRowUsed(bool includeFormats, Func predicate = null); - IXLRangeRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeRow FirstRowUsed(Func predicate = null); + IXLRangeRow FirstRowUsed(Func predicate = null); /// /// Gets the last row of the range. /// - IXLRangeRow LastRow(Func predicate = null); + IXLRangeRow LastRow(Func predicate = null); /// /// Gets the last row of the range that contains a cell with a value. /// [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow LastRowUsed(Boolean includeFormats, Func predicate = null); + IXLRangeRow LastRowUsed(bool includeFormats, Func predicate = null); - IXLRangeRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeRow LastRowUsed(Func predicate = null); + IXLRangeRow LastRowUsed(Func predicate = null); /// /// Gets the specified row of the range. @@ -153,7 +153,7 @@ public interface IXLRange : IXLRangeBase /// The relevant row IXLRangeRow Row(int row); - IXLRangeRows Rows(Func predicate = null); + IXLRangeRows Rows(Func predicate = null); /// /// Gets a collection of the specified rows in this range. @@ -222,7 +222,7 @@ public interface IXLRange : IXLRangeBase /// Number of columns to insert. IXLRangeColumns InsertColumnsAfter(int numberOfColumns); - IXLRangeColumns InsertColumnsAfter(int numberOfColumns, Boolean expandRange); + IXLRangeColumns InsertColumnsAfter(int numberOfColumns, bool expandRange); /// /// Inserts X number of columns to the left of this range. @@ -231,7 +231,7 @@ public interface IXLRange : IXLRangeBase /// Number of columns to insert. IXLRangeColumns InsertColumnsBefore(int numberOfColumns); - IXLRangeColumns InsertColumnsBefore(int numberOfColumns, Boolean expandRange); + IXLRangeColumns InsertColumnsBefore(int numberOfColumns, bool expandRange); /// /// Inserts X number of rows on top of this range. @@ -240,7 +240,7 @@ public interface IXLRange : IXLRangeBase /// Number of rows to insert. IXLRangeRows InsertRowsAbove(int numberOfRows); - IXLRangeRows InsertRowsAbove(int numberOfRows, Boolean expandRange); + IXLRangeRows InsertRowsAbove(int numberOfRows, bool expandRange); /// /// Inserts X number of rows below this range. @@ -249,7 +249,7 @@ public interface IXLRange : IXLRangeBase /// Number of rows to insert. IXLRangeRows InsertRowsBelow(int numberOfRows); - IXLRangeRows InsertRowsBelow(int numberOfRows, Boolean expandRange); + IXLRangeRows InsertRowsBelow(int numberOfRows, bool expandRange); /// /// Deletes this range and shifts the surrounding cells accordingly. @@ -265,11 +265,11 @@ public interface IXLRange : IXLRangeBase IXLTable AsTable(); - IXLTable AsTable(String name); + IXLTable AsTable(string name); IXLTable CreateTable(); - IXLTable CreateTable(String name); + IXLTable CreateTable(string name); IXLRange RangeUsed(); @@ -282,11 +282,11 @@ public interface IXLRange : IXLRangeBase IXLRange Sort(); - IXLRange Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRange Sort(string columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRange Sort(Int32 columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRange Sort(int columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); IXLRange SetDataType(XLDataType dataType); @@ -297,17 +297,17 @@ public interface IXLRange : IXLRangeBase new IXLRange Clear(XLClearOptions clearOptions = XLClearOptions.All); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRows RowsUsed(Boolean includeFormats, Func predicate = null); + IXLRangeRows RowsUsed(bool includeFormats, Func predicate = null); - IXLRangeRows RowsUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeRows RowsUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeRows RowsUsed(Func predicate = null); + IXLRangeRows RowsUsed(Func predicate = null); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumns ColumnsUsed(Boolean includeFormats, Func predicate = null); + IXLRangeColumns ColumnsUsed(bool includeFormats, Func predicate = null); - IXLRangeColumns ColumnsUsed(XLCellsUsedOptions options, Func predicate = null); + IXLRangeColumns ColumnsUsed(XLCellsUsedOptions options, Func predicate = null); - IXLRangeColumns ColumnsUsed(Func predicate = null); + IXLRangeColumns ColumnsUsed(Func predicate = null); } } diff --git a/ClosedXML/Excel/Ranges/IXLRangeAddress.cs b/ClosedXML/Excel/Ranges/IXLRangeAddress.cs index 1dc6d5073..341a279b7 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeAddress.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeAddress.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -24,7 +23,7 @@ public interface IXLRangeAddress /// /// true if this instance is valid; otherwise, false. /// - Boolean IsValid { get; } + bool IsValid { get; } /// /// Gets or sets the last address in the range. @@ -49,7 +48,7 @@ public interface IXLRangeAddress /// Allocates the current range address in the internal range repository and returns it IXLRange AsRange(); - Boolean Contains(IXLAddress address); + bool Contains(IXLAddress address); /// /// Returns the intersection of this range address with another range address on the same worksheet. @@ -58,7 +57,7 @@ public interface IXLRangeAddress /// The intersection's range address IXLRangeAddress Intersection(IXLRangeAddress otherRangeAddress); - Boolean Intersects(IXLRangeAddress otherAddress); + bool Intersects(IXLRangeAddress otherAddress); /// /// Determines whether range address spans the entire column. @@ -66,7 +65,7 @@ public interface IXLRangeAddress /// /// true if is entire column; otherwise, false. /// - Boolean IsEntireColumn(); + bool IsEntireColumn(); /// /// Determines whether range address spans the entire row. @@ -74,7 +73,7 @@ public interface IXLRangeAddress /// /// true if is entire row; otherwise, false. /// - Boolean IsEntireRow(); + bool IsEntireRow(); /// /// Determines whether the range address spans the entire worksheet. @@ -82,7 +81,7 @@ public interface IXLRangeAddress /// /// true if is entire sheet; otherwise, false. /// - Boolean IsEntireSheet(); + bool IsEntireSheet(); /// /// Returns a range address so that its offset from the target base address is equal to the offset of the current range address to the source base address. @@ -93,18 +92,18 @@ public interface IXLRangeAddress /// The relative range IXLRangeAddress Relative(IXLRangeAddress sourceRangeAddress, IXLRangeAddress targetRangeAddress); - String ToString(XLReferenceStyle referenceStyle); + string ToString(XLReferenceStyle referenceStyle); - String ToString(XLReferenceStyle referenceStyle, Boolean includeSheet); + string ToString(XLReferenceStyle referenceStyle, bool includeSheet); - String ToStringFixed(); + string ToStringFixed(); - String ToStringFixed(XLReferenceStyle referenceStyle); + string ToStringFixed(XLReferenceStyle referenceStyle); - String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeSheet); + string ToStringFixed(XLReferenceStyle referenceStyle, bool includeSheet); - String ToStringRelative(); + string ToStringRelative(); - String ToStringRelative(Boolean includeSheet); + string ToStringRelative(bool includeSheet); } } diff --git a/ClosedXML/Excel/Ranges/IXLRangeBase.cs b/ClosedXML/Excel/Ranges/IXLRangeBase.cs index 29392b904..14375e2b4 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeBase.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeBase.cs @@ -23,7 +23,7 @@ public interface IXLRangeBase : IXLAddressable /// /// The object containing the value(s) to set. /// - Object Value { set; } + object Value { set; } /// /// Sets the type of the cells' data. @@ -40,13 +40,13 @@ public interface IXLRangeBase : IXLAddressable /// Sets the cells' formula with A1 references. /// /// The formula with A1 references. - String FormulaA1 { set; } + string FormulaA1 { set; } /// /// Sets the cells' formula with R1C1 references. /// /// The formula with R1C1 references. - String FormulaR1C1 { set; } + string FormulaR1C1 { set; } IXLStyle Style { get; set; } @@ -56,7 +56,7 @@ public interface IXLRangeBase : IXLAddressable /// /// If false the cell's text will not be shared and stored as an inline value. /// - Boolean ShareString { set; } + bool ShareString { set; } IXLHyperlinks Hyperlinks { get; } @@ -65,16 +65,16 @@ public interface IXLRangeBase : IXLAddressable /// IXLCells Cells(); - IXLCells Cells(Boolean usedCellsOnly); + IXLCells Cells(bool usedCellsOnly); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells Cells(Boolean usedCellsOnly, Boolean includeFormats); + IXLCells Cells(bool usedCellsOnly, bool includeFormats); - IXLCells Cells(Boolean usedCellsOnly, XLCellsUsedOptions options); + IXLCells Cells(bool usedCellsOnly, XLCellsUsedOptions options); - IXLCells Cells(String cells); + IXLCells Cells(string cells); - IXLCells Cells(Func predicate); + IXLCells Cells(Func predicate); /// /// Returns the collection of cells that have a value. Formats are ignored. @@ -86,16 +86,16 @@ public interface IXLRangeBase : IXLAddressable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); - IXLCells CellsUsed(Func predicate); + IXLCells CellsUsed(Func predicate); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats, Func predicate); + IXLCells CellsUsed(bool includeFormats, Func predicate); - IXLCells CellsUsed(XLCellsUsedOptions options, Func predicate); + IXLCells CellsUsed(XLCellsUsedOptions options, Func predicate); /// /// Searches the cells' contents for a given piece of text @@ -104,7 +104,7 @@ public interface IXLRangeBase : IXLAddressable /// The compare options. /// if set to true search formulae instead of cell values. /// - IXLCells Search(String searchText, CompareOptions compareOptions = CompareOptions.Ordinal, Boolean searchFormulae = false); + IXLCells Search(string searchText, CompareOptions compareOptions = CompareOptions.Ordinal, bool searchFormulae = false); /// /// Returns the first cell of this range. @@ -123,16 +123,16 @@ public interface IXLRangeBase : IXLAddressable /// The cell's address is going to be ([First Row with a value], [First Column with a value]) /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell FirstCellUsed(Boolean includeFormats); + IXLCell FirstCellUsed(bool includeFormats); IXLCell FirstCellUsed(XLCellsUsedOptions options); - IXLCell FirstCellUsed(Func predicate); + IXLCell FirstCellUsed(Func predicate); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell FirstCellUsed(Boolean includeFormats, Func predicate); + IXLCell FirstCellUsed(bool includeFormats, Func predicate); - IXLCell FirstCellUsed(XLCellsUsedOptions options, Func predicate); + IXLCell FirstCellUsed(XLCellsUsedOptions options, Func predicate); /// /// Returns the last cell of this range. @@ -151,16 +151,16 @@ public interface IXLRangeBase : IXLAddressable /// The cell's address is going to be ([Last Row with a value], [Last Column with a value]) /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell LastCellUsed(Boolean includeFormats); + IXLCell LastCellUsed(bool includeFormats); IXLCell LastCellUsed(XLCellsUsedOptions options); - IXLCell LastCellUsed(Func predicate); + IXLCell LastCellUsed(Func predicate); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell LastCellUsed(Boolean includeFormats, Func predicate); + IXLCell LastCellUsed(bool includeFormats, Func predicate); - IXLCell LastCellUsed(XLCellsUsedOptions options, Func predicate); + IXLCell LastCellUsed(XLCellsUsedOptions options, Func predicate); /// /// Determines whether this range contains the specified range (completely). @@ -170,7 +170,7 @@ public interface IXLRangeBase : IXLAddressable /// /// true if this range contains the specified range; otherwise, false. /// - Boolean Contains(String rangeAddress); + bool Contains(string rangeAddress); /// /// Determines whether this range contains the specified range (completely). @@ -180,9 +180,9 @@ public interface IXLRangeBase : IXLAddressable /// /// true if this range contains the specified range; otherwise, false. /// - Boolean Contains(IXLRangeBase range); + bool Contains(IXLRangeBase range); - Boolean Contains(IXLCell cell); + bool Contains(IXLCell cell); /// /// Determines whether this range intersects the specified range. @@ -192,7 +192,7 @@ public interface IXLRangeBase : IXLAddressable /// /// true if this range intersects the specified range; otherwise, false. /// - Boolean Intersects(String rangeAddress); + bool Intersects(string rangeAddress); /// /// Determines whether this range contains the specified range. @@ -202,7 +202,7 @@ public interface IXLRangeBase : IXLAddressable /// /// true if this range intersects the specified range; otherwise, false. /// - Boolean Intersects(IXLRangeBase range); + bool Intersects(IXLRangeBase range); /// /// Unmerges this range. @@ -215,7 +215,7 @@ public interface IXLRangeBase : IXLAddressable /// IXLRange Merge(); - IXLRange Merge(Boolean checkIntersect); + IXLRange Merge(bool checkIntersect); /// /// Creates a named range out of this range. @@ -223,7 +223,7 @@ public interface IXLRangeBase : IXLAddressable /// The default scope for the named range is Workbook. /// /// Name of the range. - IXLRange AddToNamed(String rangeName); + IXLRange AddToNamed(string rangeName); /// /// Creates a named range out of this range. @@ -231,7 +231,7 @@ public interface IXLRangeBase : IXLAddressable /// Name of the range. /// The scope for the named range. /// - IXLRange AddToNamed(String rangeName, XLScope scope); + IXLRange AddToNamed(string rangeName, XLScope scope); /// /// Creates a named range out of this range. @@ -240,7 +240,7 @@ public interface IXLRangeBase : IXLAddressable /// The scope for the named range. /// The comments for the named range. /// - IXLRange AddToNamed(String rangeName, XLScope scope, String comment); + IXLRange AddToNamed(string rangeName, XLScope scope, string comment); /// /// Clears the contents of this range. @@ -260,14 +260,14 @@ public interface IXLRangeBase : IXLAddressable /// IXLRange AsRange(); - Boolean IsMerged(); + bool IsMerged(); - Boolean IsEmpty(); + bool IsEmpty(); [Obsolete("Use the overload with XLCellsUsedOptions")] - Boolean IsEmpty(Boolean includeFormats); + bool IsEmpty(bool includeFormats); - Boolean IsEmpty(XLCellsUsedOptions options); + bool IsEmpty(XLCellsUsedOptions options); /// /// Determines whether range address spans the entire column. @@ -275,7 +275,7 @@ public interface IXLRangeBase : IXLAddressable /// /// true if is entire column; otherwise, false. /// - Boolean IsEntireColumn(); + bool IsEntireColumn(); /// /// Determines whether range address spans the entire row. @@ -284,7 +284,7 @@ public interface IXLRangeBase : IXLAddressable /// true if is entire row; otherwise, false. /// - Boolean IsEntireRow(); + bool IsEntireRow(); /// /// Determines whether the range address spans the entire worksheet. @@ -292,15 +292,15 @@ public interface IXLRangeBase : IXLAddressable /// /// true if is entire sheet; otherwise, false. /// - Boolean IsEntireSheet(); + bool IsEntireSheet(); - IXLPivotTable CreatePivotTable(IXLCell targetCell, String name); + IXLPivotTable CreatePivotTable(IXLCell targetCell, string name); //IXLChart CreateChart(Int32 firstRow, Int32 firstColumn, Int32 lastRow, Int32 lastColumn); IXLAutoFilter SetAutoFilter(); - IXLAutoFilter SetAutoFilter(Boolean value); + IXLAutoFilter SetAutoFilter(bool value); /// /// Returns a data validation rule assigned to the range, if any, or creates a new instance of data validation rule if no rule exists. @@ -314,7 +314,7 @@ public interface IXLRangeBase : IXLAddressable [Obsolete("Use GetDataValidation() to access the existing rule, or CreateDataValidation() to create a new one.")] IXLDataValidation SetDataValidation(); - + IXLConditionalFormat AddConditionalFormat(); void Select(); @@ -329,7 +329,7 @@ public interface IXLRangeBase : IXLAddressable /// /// The grow count. /// - IXLRangeBase Grow(Int32 growCount); + IXLRangeBase Grow(int growCount); /// /// Shrinks this current range by one cell. @@ -341,7 +341,7 @@ public interface IXLRangeBase : IXLAddressable /// /// The shrink count. /// - IXLRangeBase Shrink(Int32 shrinkCount); + IXLRangeBase Shrink(int shrinkCount); /// /// Returns the intersection of this range with another range on the same worksheet. @@ -350,13 +350,13 @@ public interface IXLRangeBase : IXLAddressable /// Predicate applied to this range's cells. /// Predicate applied to the other range's cells. /// The range address of the intersection - IXLRangeAddress Intersection(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); + IXLRangeAddress Intersection(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); /// /// Returns the set of cells surrounding the current range. /// /// The predicate to apply on the resulting set of cells. - IXLCells SurroundingCells(Func predicate = null); + IXLCells SurroundingCells(Func predicate = null); /// /// Calculates the union of two ranges on the same worksheet. @@ -367,7 +367,7 @@ public interface IXLRangeBase : IXLAddressable /// /// The union /// - IXLCells Union(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); + IXLCells Union(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); /// /// Returns all cells in the current range that are not in the other range. @@ -376,7 +376,7 @@ public interface IXLRangeBase : IXLAddressable /// Predicate applied to this range's cells. /// Predicate applied to the other range's cells. /// - IXLCells Difference(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); + IXLCells Difference(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null); /// /// Returns a range so that its offset from the target base range is equal to the offset of the current range to the source base range. @@ -387,4 +387,4 @@ public interface IXLRangeBase : IXLAddressable /// The relative range IXLRangeBase Relative(IXLRangeBase sourceBaseRange, IXLRangeBase targetBaseRange); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Ranges/IXLRangeColumn.cs b/ClosedXML/Excel/Ranges/IXLRangeColumn.cs index 48094b3bd..5986bec79 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeColumn.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeColumn.cs @@ -8,21 +8,21 @@ public interface IXLRangeColumn : IXLRangeBase /// Gets the cell in the specified row. /// /// The cell's row. - IXLCell Cell(Int32 rowNumber); + IXLCell Cell(int rowNumber); /// /// Returns the specified group of cells, separated by commas. /// e.g. Cells("1"), Cells("1:5"), Cells("1:2,4:5") /// /// The column cells to return. - new IXLCells Cells(String cellsInColumn); + new IXLCells Cells(string cellsInColumn); /// /// Returns the specified group of cells. /// /// The first row in the group of cells to return. /// The last row in the group of cells to return. - IXLCells Cells(Int32 firstRow, Int32 lastRow); + IXLCells Cells(int firstRow, int lastRow); /// /// Inserts X number of columns to the right of this range. @@ -31,7 +31,7 @@ public interface IXLRangeColumn : IXLRangeBase /// Number of columns to insert. IXLRangeColumns InsertColumnsAfter(int numberOfColumns); - IXLRangeColumns InsertColumnsAfter(int numberOfColumns, Boolean expandRange); + IXLRangeColumns InsertColumnsAfter(int numberOfColumns, bool expandRange); /// /// Inserts X number of columns to the left of this range. @@ -40,7 +40,7 @@ public interface IXLRangeColumn : IXLRangeBase /// Number of columns to insert. IXLRangeColumns InsertColumnsBefore(int numberOfColumns); - IXLRangeColumns InsertColumnsBefore(int numberOfColumns, Boolean expandRange); + IXLRangeColumns InsertColumnsBefore(int numberOfColumns, bool expandRange); /// /// Inserts X number of cells on top of this column. @@ -49,7 +49,7 @@ public interface IXLRangeColumn : IXLRangeBase /// Number of cells to insert. IXLCells InsertCellsAbove(int numberOfRows); - IXLCells InsertCellsAbove(int numberOfRows, Boolean expandRange); + IXLCells InsertCellsAbove(int numberOfRows, bool expandRange); /// /// Inserts X number of cells below this range. @@ -58,7 +58,7 @@ public interface IXLRangeColumn : IXLRangeBase /// Number of cells to insert. IXLCells InsertCellsBelow(int numberOfRows); - IXLCells InsertCellsBelow(int numberOfRows, Boolean expandRange); + IXLCells InsertCellsBelow(int numberOfRows, bool expandRange); /// /// Deletes this range and shifts the cells at the right. @@ -74,46 +74,46 @@ public interface IXLRangeColumn : IXLRangeBase /// /// Gets this column's number in the range /// - Int32 ColumnNumber(); + int ColumnNumber(); /// /// Gets this column's letter in the range /// - String ColumnLetter(); + string ColumnLetter(); - Int32 CellCount(); + int CellCount(); IXLRangeColumn CopyTo(IXLCell target); IXLRangeColumn CopyTo(IXLRangeBase target); - IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRangeColumn Column(Int32 start, Int32 end); + IXLRangeColumn Column(int start, int end); IXLRangeColumn Column(IXLCell start, IXLCell end); - IXLRangeColumns Columns(String columns); + IXLRangeColumns Columns(string columns); IXLRangeColumn SetDataType(XLDataType dataType); IXLRangeColumn ColumnLeft(); - IXLRangeColumn ColumnLeft(Int32 step); + IXLRangeColumn ColumnLeft(int step); IXLRangeColumn ColumnRight(); - IXLRangeColumn ColumnRight(Int32 step); + IXLRangeColumn ColumnRight(int step); IXLColumn WorksheetColumn(); IXLTable AsTable(); - IXLTable AsTable(String name); + IXLTable AsTable(string name); IXLTable CreateTable(); - IXLTable CreateTable(String name); + IXLTable CreateTable(string name); /// /// Clears the contents of this column. @@ -122,7 +122,7 @@ public interface IXLRangeColumn : IXLRangeBase new IXLRangeColumn Clear(XLClearOptions clearOptions = XLClearOptions.All); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn ColumnUsed(Boolean includeFormats); + IXLRangeColumn ColumnUsed(bool includeFormats); IXLRangeColumn ColumnUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents); } diff --git a/ClosedXML/Excel/Ranges/IXLRangeColumns.cs b/ClosedXML/Excel/Ranges/IXLRangeColumns.cs index ad9711850..ffd3ab4c0 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeColumns.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeColumns.cs @@ -26,7 +26,7 @@ public interface IXLRangeColumns : IEnumerable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); diff --git a/ClosedXML/Excel/Ranges/IXLRangeRow.cs b/ClosedXML/Excel/Ranges/IXLRangeRow.cs index d709a8804..e51af3b4f 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeRow.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeRow.cs @@ -8,34 +8,34 @@ public interface IXLRangeRow : IXLRangeBase /// Gets the cell in the specified column. /// /// The cell's column. - IXLCell Cell(Int32 columnNumber); + IXLCell Cell(int columnNumber); /// /// Gets the cell in the specified column. /// /// The cell's column. - IXLCell Cell(String columnLetter); + IXLCell Cell(string columnLetter); /// /// Returns the specified group of cells, separated by commas. /// e.g. Cells("1"), Cells("1:5"), Cells("1:2,4:5") /// /// The row's cells to return. - new IXLCells Cells(String cellsInRow); + new IXLCells Cells(string cellsInRow); /// /// Returns the specified group of cells. /// /// The first column in the group of cells to return. /// The last column in the group of cells to return. - IXLCells Cells(Int32 firstColumn, Int32 lastColumn); + IXLCells Cells(int firstColumn, int lastColumn); /// /// Returns the specified group of cells. /// /// The first column in the group of cells to return. /// The last column in the group of cells to return. - IXLCells Cells(String firstColumn, String lastColumn); + IXLCells Cells(string firstColumn, string lastColumn); /// /// Inserts X number of cells to the right of this row. @@ -44,7 +44,7 @@ public interface IXLRangeRow : IXLRangeBase /// Number of cells to insert. IXLCells InsertCellsAfter(int numberOfColumns); - IXLCells InsertCellsAfter(int numberOfColumns, Boolean expandRange); + IXLCells InsertCellsAfter(int numberOfColumns, bool expandRange); /// /// Inserts X number of cells to the left of this row. @@ -53,7 +53,7 @@ public interface IXLRangeRow : IXLRangeBase /// Number of cells to insert. IXLCells InsertCellsBefore(int numberOfColumns); - IXLCells InsertCellsBefore(int numberOfColumns, Boolean expandRange); + IXLCells InsertCellsBefore(int numberOfColumns, bool expandRange); /// /// Inserts X number of rows on top of this row. @@ -62,7 +62,7 @@ public interface IXLRangeRow : IXLRangeBase /// Number of rows to insert. IXLRangeRows InsertRowsAbove(int numberOfRows); - IXLRangeRows InsertRowsAbove(int numberOfRows, Boolean expandRange); + IXLRangeRows InsertRowsAbove(int numberOfRows, bool expandRange); /// /// Inserts X number of rows below this row. @@ -71,7 +71,7 @@ public interface IXLRangeRow : IXLRangeBase /// Number of rows to insert. IXLRangeRows InsertRowsBelow(int numberOfRows); - IXLRangeRows InsertRowsBelow(int numberOfRows, Boolean expandRange); + IXLRangeRows InsertRowsBelow(int numberOfRows, bool expandRange); /// /// Deletes this range and shifts the cells below. @@ -87,9 +87,9 @@ public interface IXLRangeRow : IXLRangeBase /// /// Gets this row's number in the range /// - Int32 RowNumber(); + int RowNumber(); - Int32 CellCount(); + int CellCount(); IXLRangeRow CopyTo(IXLCell target); @@ -97,23 +97,23 @@ public interface IXLRangeRow : IXLRangeBase IXLRangeRow Sort(); - IXLRangeRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRangeRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRangeRow Row(Int32 start, Int32 end); + IXLRangeRow Row(int start, int end); IXLRangeRow Row(IXLCell start, IXLCell end); - IXLRangeRows Rows(String rows); + IXLRangeRows Rows(string rows); IXLRangeRow SetDataType(XLDataType dataType); IXLRangeRow RowAbove(); - IXLRangeRow RowAbove(Int32 step); + IXLRangeRow RowAbove(int step); IXLRangeRow RowBelow(); - IXLRangeRow RowBelow(Int32 step); + IXLRangeRow RowBelow(int step); IXLRow WorksheetRow(); @@ -124,7 +124,7 @@ public interface IXLRangeRow : IXLRangeBase new IXLRangeRow Clear(XLClearOptions clearOptions = XLClearOptions.All); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow RowUsed(Boolean includeFormats); + IXLRangeRow RowUsed(bool includeFormats); IXLRangeRow RowUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents); } diff --git a/ClosedXML/Excel/Ranges/IXLRangeRows.cs b/ClosedXML/Excel/Ranges/IXLRangeRows.cs index 280fc8de6..3acf8ffd0 100644 --- a/ClosedXML/Excel/Ranges/IXLRangeRows.cs +++ b/ClosedXML/Excel/Ranges/IXLRangeRows.cs @@ -26,7 +26,7 @@ public interface IXLRangeRows : IEnumerable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); diff --git a/ClosedXML/Excel/Ranges/IXLRanges.cs b/ClosedXML/Excel/Ranges/IXLRanges.cs index e8c318d4f..fe98b5d23 100644 --- a/ClosedXML/Excel/Ranges/IXLRanges.cs +++ b/ClosedXML/Excel/Ranges/IXLRanges.cs @@ -28,9 +28,9 @@ public interface IXLRanges : IEnumerable /// row/column shifting events. Until ranges are unsubscribed they cannot be collected by GC. void RemoveAll(Predicate match = null, bool releaseEventHandlers = true); - Int32 Count { get; } + int Count { get; } - Boolean Contains(IXLRange range); + bool Contains(IXLRange range); /// /// Filter ranges from a collection that intersect the specified address. Is much more efficient @@ -67,7 +67,7 @@ public interface IXLRanges : IEnumerable /// The default scope for the named range is Workbook. /// /// Name of the range. - IXLRanges AddToNamed(String rangeName); + IXLRanges AddToNamed(string rangeName); /// /// Creates a named range out of these ranges. @@ -75,7 +75,7 @@ public interface IXLRanges : IEnumerable /// Name of the range. /// The scope for the named range. /// - IXLRanges AddToNamed(String rangeName, XLScope scope); + IXLRanges AddToNamed(string rangeName, XLScope scope); /// /// Creates a named range out of these ranges. @@ -84,7 +84,7 @@ public interface IXLRanges : IEnumerable /// The scope for the named range. /// The comments for the named range. /// - IXLRanges AddToNamed(String rangeName, XLScope scope, String comment); + IXLRanges AddToNamed(string rangeName, XLScope scope, string comment); /// /// Sets the cells' value. @@ -96,7 +96,7 @@ public interface IXLRanges : IEnumerable /// /// The object containing the value(s) to set. /// - Object Value { set; } + object Value { set; } IXLRanges SetValue(T value); @@ -115,7 +115,7 @@ public interface IXLRanges : IEnumerable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); diff --git a/ClosedXML/Excel/Ranges/Index/XLRangeIndex.cs b/ClosedXML/Excel/Ranges/Index/XLRangeIndex.cs index fd920684b..8eecb4390 100644 --- a/ClosedXML/Excel/Ranges/Index/XLRangeIndex.cs +++ b/ClosedXML/Excel/Ranges/Index/XLRangeIndex.cs @@ -1,4 +1,5 @@ using ClosedXML.Excel.Patterns; +using ClosedXML.Excel.Tables; using System; using System.Collections.Generic; using System.Linq; @@ -28,10 +29,14 @@ public XLRangeIndex(IXLWorksheet worksheet) public bool Add(IXLAddressable range) { if (range == null) + { throw new ArgumentNullException(nameof(range)); + } if (!range.RangeAddress.IsValid) + { throw new ArgumentException("Range is invalid"); + } CheckWorksheet(range.RangeAddress.Worksheet); @@ -39,14 +44,18 @@ public bool Add(IXLAddressable range) if (_count < MinimumCountForIndexing) { if (_rangeList.Any(r => r == range)) + { return false; + } _rangeList.Add(range); return true; } if (_quadTree == null) + { InitializeTree(); + } return _quadTree.Add(range); } @@ -114,7 +123,9 @@ public bool Intersects(in XLRangeAddress rangeAddress) public bool Remove(IXLRangeAddress rangeAddress) { if (rangeAddress == null) + { throw new ArgumentNullException(nameof(rangeAddress)); + } CheckWorksheet(rangeAddress.Worksheet); @@ -155,7 +166,7 @@ public int RemoveAll(Predicate predicate = null) protected readonly List _rangeList; private readonly IXLWorksheet _worksheet; - private int _count = 0; + private int _count; protected Quadrant _quadTree; #endregion Private Fields @@ -165,7 +176,9 @@ public int RemoveAll(Predicate predicate = null) private void CheckWorksheet(IXLWorksheet worksheet) { if (worksheet != _worksheet) + { throw new ArgumentException("Range belongs to a different worksheet"); + } } private void InitializeTree() @@ -221,7 +234,9 @@ public override bool MatchesType(XLRangeType rangeType) if (innerType == typeof(IXLRangeBase) || innerType == typeof(XLRangeBase)) + { return true; + } switch (rangeType) { diff --git a/ClosedXML/Excel/Ranges/Sort/IXLSortElement.cs b/ClosedXML/Excel/Ranges/Sort/IXLSortElement.cs index e7ec5d908..e8940b6e7 100644 --- a/ClosedXML/Excel/Ranges/Sort/IXLSortElement.cs +++ b/ClosedXML/Excel/Ranges/Sort/IXLSortElement.cs @@ -1,14 +1,12 @@ -using System; - namespace ClosedXML.Excel { public enum XLSortOrder { Ascending, Descending } public enum XLSortOrientation { TopToBottom, LeftToRight } public interface IXLSortElement { - Int32 ElementNumber { get; set; } + int ElementNumber { get; set; } XLSortOrder SortOrder { get; set; } - Boolean IgnoreBlanks { get; set; } - Boolean MatchCase { get; set; } + bool IgnoreBlanks { get; set; } + bool MatchCase { get; set; } } } diff --git a/ClosedXML/Excel/Ranges/Sort/IXLSortElements.cs b/ClosedXML/Excel/Ranges/Sort/IXLSortElements.cs index 24f2fc99e..31b2c7e15 100644 --- a/ClosedXML/Excel/Ranges/Sort/IXLSortElements.cs +++ b/ClosedXML/Excel/Ranges/Sort/IXLSortElements.cs @@ -1,22 +1,21 @@ -using System; using System.Collections.Generic; namespace ClosedXML.Excel { public interface IXLSortElements: IEnumerable { - void Add(Int32 elementNumber); - void Add(Int32 elementNumber, XLSortOrder sortOrder); - void Add(Int32 elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks); - void Add(Int32 elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks, Boolean matchCase); + void Add(int elementNumber); + void Add(int elementNumber, XLSortOrder sortOrder); + void Add(int elementNumber, XLSortOrder sortOrder, bool ignoreBlanks); + void Add(int elementNumber, XLSortOrder sortOrder, bool ignoreBlanks, bool matchCase); - void Add(String elementNumber); - void Add(String elementNumber, XLSortOrder sortOrder); - void Add(String elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks); - void Add(String elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks, Boolean matchCase); + void Add(string elementNumber); + void Add(string elementNumber, XLSortOrder sortOrder); + void Add(string elementNumber, XLSortOrder sortOrder, bool ignoreBlanks); + void Add(string elementNumber, XLSortOrder sortOrder, bool ignoreBlanks, bool matchCase); void Clear(); - void Remove(Int32 elementNumber); + void Remove(int elementNumber); } } diff --git a/ClosedXML/Excel/Ranges/Sort/XLSortElement.cs b/ClosedXML/Excel/Ranges/Sort/XLSortElement.cs index bb801d73a..c1bc9a7a0 100644 --- a/ClosedXML/Excel/Ranges/Sort/XLSortElement.cs +++ b/ClosedXML/Excel/Ranges/Sort/XLSortElement.cs @@ -1,12 +1,10 @@ -using System; - namespace ClosedXML.Excel { internal class XLSortElement: IXLSortElement { - public Int32 ElementNumber { get; set; } + public int ElementNumber { get; set; } public XLSortOrder SortOrder { get; set; } - public Boolean IgnoreBlanks { get; set; } - public Boolean MatchCase { get; set; } + public bool IgnoreBlanks { get; set; } + public bool MatchCase { get; set; } } } diff --git a/ClosedXML/Excel/Ranges/Sort/XLSortElements.cs b/ClosedXML/Excel/Ranges/Sort/XLSortElements.cs index 7aa7c8b57..07d57e8f2 100644 --- a/ClosedXML/Excel/Ranges/Sort/XLSortElements.cs +++ b/ClosedXML/Excel/Ranges/Sort/XLSortElements.cs @@ -1,24 +1,27 @@ -using System; using System.Collections.Generic; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.Ranges.Sort { - internal class XLSortElements: IXLSortElements + internal class XLSortElements : IXLSortElements { - List elements = new List(); - public void Add(Int32 elementNumber) + private readonly List elements = new List(); + + public void Add(int elementNumber) { Add(elementNumber, XLSortOrder.Ascending); } - public void Add(Int32 elementNumber, XLSortOrder sortOrder) + + public void Add(int elementNumber, XLSortOrder sortOrder) { Add(elementNumber, sortOrder, true); } - public void Add(Int32 elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks) + + public void Add(int elementNumber, XLSortOrder sortOrder, bool ignoreBlanks) { Add(elementNumber, sortOrder, ignoreBlanks, false); } - public void Add(Int32 elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks, Boolean matchCase) + + public void Add(int elementNumber, XLSortOrder sortOrder, bool ignoreBlanks, bool matchCase) { elements.Add(new XLSortElement() { @@ -29,19 +32,22 @@ public void Add(Int32 elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks }); } - public void Add(String elementNumber) + public void Add(string elementNumber) { Add(elementNumber, XLSortOrder.Ascending); } - public void Add(String elementNumber, XLSortOrder sortOrder) + + public void Add(string elementNumber, XLSortOrder sortOrder) { Add(elementNumber, sortOrder, true); } - public void Add(String elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks) + + public void Add(string elementNumber, XLSortOrder sortOrder, bool ignoreBlanks) { Add(elementNumber, sortOrder, ignoreBlanks, false); } - public void Add(String elementNumber, XLSortOrder sortOrder, Boolean ignoreBlanks, Boolean matchCase) + + public void Add(string elementNumber, XLSortOrder sortOrder, bool ignoreBlanks, bool matchCase) { elements.Add(new XLSortElement() { @@ -67,9 +73,9 @@ public void Clear() elements.Clear(); } - public void Remove(Int32 elementNumber) + public void Remove(int elementNumber) { elements.RemoveAt(elementNumber - 1); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Ranges/XLRange.cs b/ClosedXML/Excel/Ranges/XLRange.cs index 9551abbe4..6e9cb8c31 100644 --- a/ClosedXML/Excel/Ranges/XLRange.cs +++ b/ClosedXML/Excel/Ranges/XLRange.cs @@ -1,8 +1,9 @@ +using ClosedXML.Excel.Tables; using System; using System.Collections.Generic; using System.Linq; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.Ranges { internal class XLRange : XLRangeBase, IXLRange { @@ -15,67 +16,69 @@ public XLRange(XLRangeParameters xlRangeParameters) #endregion Constructor - public override XLRangeType RangeType - { - get { return XLRangeType.Range; } - } + public override XLRangeType RangeType => XLRangeType.Range; #region IXLRange Members - IXLRangeRow IXLRange.Row(Int32 row) + IXLRangeRow IXLRange.Row(int row) { return Row(row); } - IXLRangeColumn IXLRange.Column(Int32 columnNumber) + IXLRangeColumn IXLRange.Column(int columnNumber) { return Column(columnNumber); } - IXLRangeColumn IXLRange.Column(String columnLetter) + IXLRangeColumn IXLRange.Column(string columnLetter) { return Column(columnLetter); } - public virtual IXLRangeColumns Columns(Func predicate = null) + public virtual IXLRangeColumns Columns(Func predicate = null) { var retVal = new XLRangeColumns(); - Int32 columnCount = ColumnCount(); - for (Int32 c = 1; c <= columnCount; c++) + var columnCount = ColumnCount(); + for (var c = 1; c <= columnCount; c++) { var column = Column(c); if (predicate == null || predicate(column)) + { retVal.Add(column); + } } return retVal; } - public virtual IXLRangeColumns Columns(Int32 firstColumn, Int32 lastColumn) + public virtual IXLRangeColumns Columns(int firstColumn, int lastColumn) { var retVal = new XLRangeColumns(); - for (int co = firstColumn; co <= lastColumn; co++) + for (var co = firstColumn; co <= lastColumn; co++) + { retVal.Add(Column(co)); + } + return retVal; } - public virtual IXLRangeColumns Columns(String firstColumn, String lastColumn) + public virtual IXLRangeColumns Columns(string firstColumn, string lastColumn) { return Columns(XLHelper.GetColumnNumberFromLetter(firstColumn), XLHelper.GetColumnNumberFromLetter(lastColumn)); } - public virtual IXLRangeColumns Columns(String columns) + public virtual IXLRangeColumns Columns(string columns) { var retVal = new XLRangeColumns(); var columnPairs = columns.Split(','); - foreach (string tPair in columnPairs.Select(pair => pair.Trim())) + foreach (var tPair in columnPairs.Select(pair => pair.Trim())) { - String firstColumn; - String lastColumn; + string firstColumn; + string lastColumn; if (tPair.Contains(':') || tPair.Contains('-')) { - string[] columnRange = XLHelper.SplitRange(tPair); + var columnRange = XLHelper.SplitRange(tPair); firstColumn = columnRange[0]; lastColumn = columnRange[1]; @@ -86,15 +89,19 @@ public virtual IXLRangeColumns Columns(String columns) lastColumn = tPair; } - if (Int32.TryParse(firstColumn, out Int32 tmp)) + if (int.TryParse(firstColumn, out var tmp)) { - foreach (IXLRangeColumn col in Columns(Int32.Parse(firstColumn), Int32.Parse(lastColumn))) + foreach (var col in Columns(int.Parse(firstColumn), int.Parse(lastColumn))) + { retVal.Add(col); + } } else { - foreach (IXLRangeColumn col in Columns(firstColumn, lastColumn)) + foreach (var col in Columns(firstColumn, lastColumn)) + { retVal.Add(col); + } } } return retVal; @@ -150,39 +157,44 @@ IXLRange IXLRange.Range(int firstCellRow, int firstCellColumn, int lastCellRow, return Range(firstCellRow, firstCellColumn, lastCellRow, lastCellColumn); } - public IXLRangeRows Rows(Func predicate = null) + public IXLRangeRows Rows(Func predicate = null) { var retVal = new XLRangeRows(); - Int32 rowCount = RowCount(); - for (Int32 r = 1; r <= rowCount; r++) + var rowCount = RowCount(); + for (var r = 1; r <= rowCount; r++) { var row = Row(r); if (predicate == null || predicate(row)) + { retVal.Add(Row(r)); + } } return retVal; } - public IXLRangeRows Rows(Int32 firstRow, Int32 lastRow) + public IXLRangeRows Rows(int firstRow, int lastRow) { var retVal = new XLRangeRows(); - for (int ro = firstRow; ro <= lastRow; ro++) + for (var ro = firstRow; ro <= lastRow; ro++) + { retVal.Add(Row(ro)); + } + return retVal; } - public IXLRangeRows Rows(String rows) + public IXLRangeRows Rows(string rows) { var retVal = new XLRangeRows(); var rowPairs = rows.Split(','); - foreach (string tPair in rowPairs.Select(pair => pair.Trim())) + foreach (var tPair in rowPairs.Select(pair => pair.Trim())) { - String firstRow; - String lastRow; + string firstRow; + string lastRow; if (tPair.Contains(':') || tPair.Contains('-')) { - string[] rowRange = XLHelper.SplitRange(tPair); + var rowRange = XLHelper.SplitRange(tPair); firstRow = rowRange[0]; lastRow = rowRange[1]; @@ -192,17 +204,19 @@ public IXLRangeRows Rows(String rows) firstRow = tPair; lastRow = tPair; } - foreach (IXLRangeRow row in Rows(Int32.Parse(firstRow), Int32.Parse(lastRow))) + foreach (var row in Rows(int.Parse(firstRow), int.Parse(lastRow))) + { retVal.Add(row); + } } return retVal; } public void Transpose(XLTransposeOptions transposeOption) { - int rowCount = RowCount(); - int columnCount = ColumnCount(); - int squareSide = rowCount > columnCount ? rowCount : columnCount; + var rowCount = RowCount(); + var columnCount = ColumnCount(); + var squareSide = rowCount > columnCount ? rowCount : columnCount; var firstCell = FirstCell(); @@ -236,7 +250,7 @@ public void Transpose(XLTransposeOptions transposeOption) rng.Delete(XLShiftDeletedCells.ShiftCellsLeft); } - foreach (IXLCell c in Range(1, 1, columnCount, rowCount).Cells()) + foreach (var c in Range(1, 1, columnCount, rowCount).Cells()) { var border = (c.Style as XLStyle).Value.Border; c.Style.Border.TopBorder = border.LeftBorder; @@ -255,7 +269,7 @@ public IXLTable AsTable() return Worksheet.Table(this, false); } - public IXLTable AsTable(String name) + public IXLTable AsTable(string name) { return Worksheet.Table(this, name, false); } @@ -270,17 +284,17 @@ public XLTable CreateTable() return (XLTable)Worksheet.Table(this, true, true); } - IXLTable IXLRange.CreateTable(String name) + IXLTable IXLRange.CreateTable(string name) { return CreateTable(name); } - public XLTable CreateTable(String name) + public XLTable CreateTable(string name) { return (XLTable)Worksheet.Table(this, name, true, true); } - public IXLTable CreateTable(String name, Boolean setAutofilter) + public IXLTable CreateTable(string name, bool setAutofilter) { return Worksheet.Table(this, name, true, setAutofilter); } @@ -289,12 +303,17 @@ public IXLTable CreateTable(String name, Boolean setAutofilter) { base.CopyTo(target); - Int32 lastRowNumber = target.Address.RowNumber + RowCount() - 1; + var lastRowNumber = target.Address.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - Int32 lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range(target.Address.RowNumber, target.Address.ColumnNumber, @@ -306,12 +325,17 @@ public IXLTable CreateTable(String name, Boolean setAutofilter) { base.CopyTo(target); - Int32 lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; + var lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - Int32 lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range(target.RangeAddress.FirstAddress.RowNumber, target.RangeAddress.FirstAddress.ColumnNumber, @@ -330,17 +354,17 @@ public IXLRange SetDataType(XLDataType dataType) return base.Sort().AsRange(); } - public new IXLRange Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange Sort(string columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { return base.Sort(columnsToSortBy, sortOrder, matchCase, ignoreBlanks).AsRange(); } - public new IXLRange Sort(Int32 columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange Sort(int columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { return base.Sort(columnToSortBy, sortOrder, matchCase, ignoreBlanks).AsRange(); } - public new IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { return base.SortLeftToRight(sortOrder, matchCase, ignoreBlanks).AsRange(); } @@ -357,58 +381,68 @@ internal override void WorksheetRangeShiftedRows(XLRange range, int rowsShifted) RangeAddress = (XLRangeAddress)ShiftRows(RangeAddress, range, rowsShifted); } - IXLRangeColumn IXLRange.FirstColumn(Func predicate) + IXLRangeColumn IXLRange.FirstColumn(Func predicate) { return FirstColumn(predicate); } - internal XLRangeColumn FirstColumn(Func predicate = null) + internal XLRangeColumn FirstColumn(Func predicate = null) { if (predicate == null) + { return Column(1); + } - Int32 columnCount = ColumnCount(); - for (Int32 c = 1; c <= columnCount; c++) + var columnCount = ColumnCount(); + for (var c = 1; c <= columnCount; c++) { var column = Column(c); - if (predicate(column)) return column; + if (predicate(column)) + { + return column; + } } return null; } - IXLRangeColumn IXLRange.LastColumn(Func predicate) + IXLRangeColumn IXLRange.LastColumn(Func predicate) { return LastColumn(predicate); } - internal XLRangeColumn LastColumn(Func predicate = null) + internal XLRangeColumn LastColumn(Func predicate = null) { - Int32 columnCount = ColumnCount(); + var columnCount = ColumnCount(); if (predicate == null) + { return Column(columnCount); + } - for (Int32 c = columnCount; c >= 1; c--) + for (var c = columnCount; c >= 1; c--) { var column = Column(c); - if (predicate(column)) return column; + if (predicate(column)) + { + return column; + } } return null; } - IXLRangeColumn IXLRange.FirstColumnUsed(Func predicate) + IXLRangeColumn IXLRange.FirstColumnUsed(Func predicate) { return FirstColumnUsed(XLCellsUsedOptions.AllContents, predicate); } - internal XLRangeColumn FirstColumnUsed(Func predicate = null) + internal XLRangeColumn FirstColumnUsed(Func predicate = null) { return FirstColumnUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn IXLRange.FirstColumnUsed(Boolean includeFormats, Func predicate) + IXLRangeColumn IXLRange.FirstColumnUsed(bool includeFormats, Func predicate) { return FirstColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -416,16 +450,16 @@ IXLRangeColumn IXLRange.FirstColumnUsed(Boolean includeFormats, Func predicate) + IXLRangeColumn IXLRange.FirstColumnUsed(XLCellsUsedOptions options, Func predicate) { return FirstColumnUsed(options, predicate); } - internal XLRangeColumn FirstColumnUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLRangeColumn FirstColumnUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) { - Int32 firstColumnUsed = Worksheet.Internals.CellsCollection.FirstColumnUsed( + var firstColumnUsed = Worksheet.Internals.CellsCollection.FirstColumnUsed( RangeAddress.FirstAddress.RowNumber, RangeAddress.FirstAddress.ColumnNumber, RangeAddress.LastAddress.RowNumber, @@ -435,29 +469,31 @@ internal XLRangeColumn FirstColumnUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeColumn IXLRange.LastColumnUsed(Func predicate) { return LastColumnUsed(XLCellsUsedOptions.AllContents, predicate); } - internal XLRangeColumn LastColumnUsed(Func predicate = null) + internal XLRangeColumn LastColumnUsed(Func predicate = null) { return LastColumnUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeColumn IXLRange.LastColumnUsed(Boolean includeFormats, Func predicate) + IXLRangeColumn IXLRange.LastColumnUsed(bool includeFormats, Func predicate) { return LastColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -465,16 +501,16 @@ IXLRangeColumn IXLRange.LastColumnUsed(Boolean includeFormats, Func predicate) + IXLRangeColumn IXLRange.LastColumnUsed(XLCellsUsedOptions options, Func predicate) { return LastColumnUsed(options, predicate); } - internal XLRangeColumn LastColumnUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLRangeColumn LastColumnUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) { - Int32 lastColumnUsed = Worksheet.Internals.CellsCollection.LastColumnUsed( + var lastColumnUsed = Worksheet.Internals.CellsCollection.LastColumnUsed( RangeAddress.FirstAddress.RowNumber, RangeAddress.FirstAddress.ColumnNumber, RangeAddress.LastAddress.RowNumber, @@ -484,85 +520,97 @@ internal XLRangeColumn LastColumnUsed(XLCellsUsedOptions options, Func= 1; co--) + var columnCount = ColumnCount(); + for (var co = columnCount; co >= 1; co--) { var column = Column(co); if (!column.IsEmpty(options) && predicate(column)) + { return column; + } } return null; } - IXLRangeRow IXLRange.FirstRow(Func predicate) + IXLRangeRow IXLRange.FirstRow(Func predicate) { return FirstRow(predicate); } - public XLRangeRow FirstRow(Func predicate = null) + public XLRangeRow FirstRow(Func predicate = null) { if (predicate == null) + { return Row(1); + } - Int32 rowCount = RowCount(); - for (Int32 ro = 1; ro <= rowCount; ro++) + var rowCount = RowCount(); + for (var ro = 1; ro <= rowCount; ro++) { var row = Row(ro); - if (predicate(row)) return row; + if (predicate(row)) + { + return row; + } } return null; } - IXLRangeRow IXLRange.LastRow(Func predicate) + IXLRangeRow IXLRange.LastRow(Func predicate) { return LastRow(predicate); } - public XLRangeRow LastRow(Func predicate = null) + public XLRangeRow LastRow(Func predicate = null) { - Int32 rowCount = RowCount(); + var rowCount = RowCount(); if (predicate == null) + { return Row(rowCount); + } - for (Int32 ro = rowCount; ro >= 1; ro--) + for (var ro = rowCount; ro >= 1; ro--) { var row = Row(ro); - if (predicate(row)) return row; + if (predicate(row)) + { + return row; + } } return null; } - IXLRangeRow IXLRange.FirstRowUsed(Func predicate) + IXLRangeRow IXLRange.FirstRowUsed(Func predicate) { return FirstRowUsed(XLCellsUsedOptions.AllContents, predicate); } - internal XLRangeRow FirstRowUsed(Func predicate = null) + internal XLRangeRow FirstRowUsed(Func predicate = null) { return FirstRowUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow IXLRange.FirstRowUsed(Boolean includeFormats, Func predicate) + IXLRangeRow IXLRange.FirstRowUsed(bool includeFormats, Func predicate) { return FirstRowUsed(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents, predicate); } - IXLRangeRow IXLRange.FirstRowUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeRow IXLRange.FirstRowUsed(XLCellsUsedOptions options, Func predicate) { return FirstRowUsed(options, predicate); } - internal XLRangeRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLRangeRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) { - Int32 rowFromCells = Worksheet.Internals.CellsCollection.FirstRowUsed( + var rowFromCells = Worksheet.Internals.CellsCollection.FirstRowUsed( RangeAddress.FirstAddress.RowNumber, RangeAddress.FirstAddress.ColumnNumber, RangeAddress.LastAddress.RowNumber, @@ -574,45 +622,47 @@ internal XLRangeRow FirstRowUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeRow IXLRange.LastRowUsed(Func predicate) { return LastRowUsed(XLCellsUsedOptions.AllContents, predicate); } - internal XLRangeRow LastRowUsed(Func predicate = null) + internal XLRangeRow LastRowUsed(Func predicate = null) { return LastRowUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow IXLRange.LastRowUsed(Boolean includeFormats, Func predicate) + IXLRangeRow IXLRange.LastRowUsed(bool includeFormats, Func predicate) { return LastRowUsed(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents, predicate); } - IXLRangeRow IXLRange.LastRowUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeRow IXLRange.LastRowUsed(XLCellsUsedOptions options, Func predicate) { return LastRowUsed(options, predicate); } - internal XLRangeRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLRangeRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) { - Int32 lastRowUsed = Worksheet.Internals.CellsCollection.LastRowUsed( + var lastRowUsed = Worksheet.Internals.CellsCollection.LastRowUsed( RangeAddress.FirstAddress.RowNumber, RangeAddress.FirstAddress.ColumnNumber, RangeAddress.LastAddress.RowNumber, @@ -622,96 +672,104 @@ internal XLRangeRow LastRowUsed(XLCellsUsedOptions options, Func= 1; ro--) + var rowCount = RowCount(); + for (var ro = rowCount; ro >= 1; ro--) { var row = Row(ro); if (!row.IsEmpty(options) && predicate(row)) + { return row; + } } return null; } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRows IXLRange.RowsUsed(Boolean includeFormats, Func predicate) + IXLRangeRows IXLRange.RowsUsed(bool includeFormats, Func predicate) { return RowsUsed(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents, predicate); } - IXLRangeRows IXLRange.RowsUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeRows IXLRange.RowsUsed(XLCellsUsedOptions options, Func predicate) { return RowsUsed(options, predicate); } - internal XLRangeRows RowsUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLRangeRows RowsUsed(XLCellsUsedOptions options, Func predicate = null) { - XLRangeRows rows = new XLRangeRows(); - Int32 rowCount = RowCount(options); + var rows = new XLRangeRows(); + var rowCount = RowCount(options); - for (Int32 ro = 1; ro <= rowCount; ro++) + for (var ro = 1; ro <= rowCount; ro++) { var row = Row(ro); if (!row.IsEmpty(options) && (predicate == null || predicate(row))) + { rows.Add(row); + } } return rows; } - IXLRangeRows IXLRange.RowsUsed(Func predicate) + IXLRangeRows IXLRange.RowsUsed(Func predicate) { return RowsUsed(predicate); } - internal XLRangeRows RowsUsed(Func predicate = null) + internal XLRangeRows RowsUsed(Func predicate = null) { return RowsUsed(XLCellsUsedOptions.AllContents, predicate); } - IXLRangeColumns IXLRange.ColumnsUsed(Boolean includeFormats, Func predicate) + IXLRangeColumns IXLRange.ColumnsUsed(bool includeFormats, Func predicate) { return ColumnsUsed(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents, predicate); } - IXLRangeColumns IXLRange.ColumnsUsed(XLCellsUsedOptions options, Func predicate) + IXLRangeColumns IXLRange.ColumnsUsed(XLCellsUsedOptions options, Func predicate) { return ColumnsUsed(options, predicate); } - internal virtual XLRangeColumns ColumnsUsed(XLCellsUsedOptions options, Func predicate = null) + internal virtual XLRangeColumns ColumnsUsed(XLCellsUsedOptions options, Func predicate = null) { - XLRangeColumns columns = new XLRangeColumns(); - Int32 columnCount = ColumnCount(options); + var columns = new XLRangeColumns(); + var columnCount = ColumnCount(options); - for (Int32 co = 1; co <= columnCount; co++) + for (var co = 1; co <= columnCount; co++) { var column = Column(co); if (!column.IsEmpty(options) && (predicate == null || predicate(column))) + { columns.Add(column); + } } return columns; } - IXLRangeColumns IXLRange.ColumnsUsed(Func predicate) + IXLRangeColumns IXLRange.ColumnsUsed(Func predicate) { return ColumnsUsed(predicate); } - internal virtual XLRangeColumns ColumnsUsed(Func predicate = null) + internal virtual XLRangeColumns ColumnsUsed(Func predicate = null) { return ColumnsUsed(XLCellsUsedOptions.AllContents, predicate); } - public XLRangeRow Row(Int32 row) + public XLRangeRow Row(int row) { if (row <= 0 || row > XLHelper.MaxRowNumber + RangeAddress.FirstAddress.RowNumber - 1) - throw new ArgumentOutOfRangeException(nameof(row), String.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber + RangeAddress.FirstAddress.RowNumber - 1)); + { + throw new ArgumentOutOfRangeException(nameof(row), string.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber + RangeAddress.FirstAddress.RowNumber - 1)); + } var firstCellAddress = new XLAddress(Worksheet, RangeAddress.FirstAddress.RowNumber + row - 1, @@ -727,10 +785,12 @@ public XLRangeRow Row(Int32 row) return Worksheet.RangeRow(new XLRangeAddress(firstCellAddress, lastCellAddress)); } - public virtual XLRangeColumn Column(Int32 columnNumber) + public virtual XLRangeColumn Column(int columnNumber) { if (columnNumber <= 0 || columnNumber > XLHelper.MaxColumnNumber + RangeAddress.FirstAddress.ColumnNumber - 1) - throw new ArgumentOutOfRangeException(nameof(columnNumber), String.Format("Column number must be between 1 and {0}", XLHelper.MaxColumnNumber + RangeAddress.FirstAddress.ColumnNumber - 1)); + { + throw new ArgumentOutOfRangeException(nameof(columnNumber), string.Format("Column number must be between 1 and {0}", XLHelper.MaxColumnNumber + RangeAddress.FirstAddress.ColumnNumber - 1)); + } var firstCellAddress = new XLAddress(Worksheet, RangeAddress.FirstAddress.RowNumber, @@ -745,7 +805,7 @@ public virtual XLRangeColumn Column(Int32 columnNumber) return Worksheet.RangeColumn(new XLRangeAddress(firstCellAddress, lastCellAddress)); } - public virtual XLRangeColumn Column(String columnLetter) + public virtual XLRangeColumn Column(string columnLetter) { return Column(XLHelper.GetColumnNumberFromLetter(columnLetter)); } @@ -813,11 +873,11 @@ private void TransposeRange(int squareSide) RangeAddress.FirstAddress.RowNumber + squareSide - 1, RangeAddress.FirstAddress.ColumnNumber + squareSide - 1); - Int32 roCount = rngToTranspose.RowCount(); - Int32 coCount = rngToTranspose.ColumnCount(); - for (Int32 ro = 1; ro <= roCount; ro++) + var roCount = rngToTranspose.RowCount(); + var coCount = rngToTranspose.ColumnCount(); + for (var ro = 1; ro <= roCount; ro++) { - for (Int32 co = 1; co <= coCount; co++) + for (var co = 1; co <= coCount; co++) { var oldCell = rngToTranspose.Cell(ro, co); var newKey = rngToTranspose.Cell(co, ro).Address; @@ -833,7 +893,7 @@ private void TransposeRange(int squareSide) cellsToInsert.ForEach(c => Worksheet.Internals.CellsCollection.Add(c.Key, c.Value)); } - private void TransposeMerged(Int32 squareSide) + private void TransposeMerged(int squareSide) { var rngToTranspose = Worksheet.Range( RangeAddress.FirstAddress.RowNumber, @@ -854,15 +914,19 @@ private void MoveOrClearForTranspose(XLTransposeOptions transposeOption, int row if (transposeOption == XLTransposeOptions.MoveCells) { if (rowCount > columnCount) + { InsertColumnsAfter(false, rowCount - columnCount, false); + } else if (columnCount > rowCount) + { InsertRowsBelow(false, columnCount - rowCount, false); + } } else { if (rowCount > columnCount) { - int toMove = rowCount - columnCount; + var toMove = rowCount - columnCount; var rngToClear = Worksheet.Range( RangeAddress.FirstAddress.RowNumber, RangeAddress.LastAddress.ColumnNumber + 1, @@ -872,7 +936,7 @@ private void MoveOrClearForTranspose(XLTransposeOptions transposeOption, int row } else if (columnCount > rowCount) { - int toMove = columnCount - rowCount; + var toMove = columnCount - rowCount; var rngToClear = Worksheet.Range( RangeAddress.LastAddress.RowNumber + 1, RangeAddress.FirstAddress.ColumnNumber, @@ -885,9 +949,11 @@ private void MoveOrClearForTranspose(XLTransposeOptions transposeOption, int row public override bool Equals(object obj) { - var other = obj as XLRange; - if (other == null) + if (!(obj is XLRange other)) + { return false; + } + return RangeAddress.Equals(other.RangeAddress) && Worksheet.Equals(other.Worksheet); } @@ -906,24 +972,28 @@ public override int GetHashCode() public IXLRangeColumn FindColumn(Func predicate) { - Int32 columnCount = ColumnCount(); - for (Int32 c = 1; c <= columnCount; c++) + var columnCount = ColumnCount(); + for (var c = 1; c <= columnCount; c++) { var column = Column(c); if (predicate == null || predicate(column)) + { return column; + } } return null; } public IXLRangeRow FindRow(Func predicate) { - Int32 rowCount = RowCount(); - for (Int32 r = 1; r <= rowCount; r++) + var rowCount = RowCount(); + for (var r = 1; r <= rowCount; r++) { var row = Row(r); if (predicate(row)) + { return row; + } } return null; } @@ -936,7 +1006,7 @@ public override string ToString() } else if (IsEntireRow()) { - return String.Concat( + return string.Concat( Worksheet.Name.EscapeSheetName(), '!', RangeAddress.FirstAddress.RowNumber, @@ -945,7 +1015,7 @@ public override string ToString() } else if (IsEntireColumn()) { - return String.Concat( + return string.Concat( Worksheet.Name.EscapeSheetName(), '!', RangeAddress.FirstAddress.ColumnLetter, @@ -953,7 +1023,9 @@ public override string ToString() RangeAddress.LastAddress.ColumnLetter); } else + { return base.ToString(); + } } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Ranges/XLRangeAddress.cs b/ClosedXML/Excel/Ranges/XLRangeAddress.cs index a18365bae..56525d89d 100644 --- a/ClosedXML/Excel/Ranges/XLRangeAddress.cs +++ b/ClosedXML/Excel/Ranges/XLRangeAddress.cs @@ -1,4 +1,3 @@ -using ClosedXML.Extensions; using System; using System.Collections.Generic; using System.Diagnostics; @@ -40,9 +39,9 @@ public XLRangeAddress(XLAddress firstAddress, XLAddress lastAddress) : this() LastAddress = lastAddress; } - public XLRangeAddress(XLWorksheet worksheet, String rangeAddress) : this() + public XLRangeAddress(XLWorksheet worksheet, string rangeAddress) : this() { - string addressToUse = rangeAddress.Contains("!") + var addressToUse = rangeAddress.Contains("!") ? rangeAddress.Substring(rangeAddress.LastIndexOf("!") + 1) : rangeAddress; @@ -67,8 +66,8 @@ public XLRangeAddress(XLWorksheet worksheet, String rangeAddress) : this() } else { - firstPart = firstPart.Replace("$", String.Empty); - secondPart = secondPart.Replace("$", String.Empty); + firstPart = firstPart.Replace("$", string.Empty); + secondPart = secondPart.Replace("$", string.Empty); if (char.IsDigit(firstPart[0])) { FirstAddress = XLAddress.Create(worksheet, "A" + firstPart); @@ -94,10 +93,7 @@ public XLRangeAddress(XLWorksheet worksheet, String rangeAddress) : this() public XLAddress LastAddress { get; } - IXLWorksheet IXLRangeAddress.Worksheet - { - get { return Worksheet; } - } + IXLWorksheet IXLRangeAddress.Worksheet => Worksheet; IXLAddress IXLRangeAddress.FirstAddress { @@ -118,7 +114,9 @@ public int ColumnSpan get { if (!IsValid) + { throw new InvalidOperationException("Range address is invalid."); + } return Math.Abs(LastAddress.ColumnNumber - FirstAddress.ColumnNumber) + 1; } @@ -131,7 +129,9 @@ public int RowSpan get { if (!IsValid) + { throw new InvalidOperationException("Range address is invalid."); + } return Math.Abs(LastAddress.RowNumber - FirstAddress.RowNumber) + 1; } @@ -143,7 +143,7 @@ public int RowSpan #region Public methods - public Boolean IsNormalized => LastAddress.RowNumber >= FirstAddress.RowNumber + public bool IsNormalized => LastAddress.RowNumber >= FirstAddress.RowNumber && LastAddress.ColumnNumber >= FirstAddress.ColumnNumber; /// @@ -155,7 +155,9 @@ public XLRangeAddress Normalize() { if (FirstAddress.RowNumber <= LastAddress.RowNumber && FirstAddress.ColumnNumber <= LastAddress.ColumnNumber) + { return this; + } int firstRow, firstColumn, lastRow, lastColumn; bool firstRowFixed, firstColumnFixed, lastRowFixed, lastColumnFixed; @@ -232,67 +234,91 @@ internal bool Contains(in XLAddress address) address.ColumnNumber <= LastAddress.ColumnNumber; } - public String ToStringRelative() + public string ToStringRelative() { return ToStringRelative(false); } - public String ToStringFixed() + public string ToStringFixed() { return ToStringFixed(XLReferenceStyle.A1); } - public String ToStringRelative(Boolean includeSheet) + public string ToStringRelative(bool includeSheet) { string address; if (!IsValid) + { address = "#REF!"; + } else { if (IsEntireSheet()) + { address = $"1:{XLHelper.MaxRowNumber}"; + } else if (IsEntireRow()) - address = String.Concat(FirstAddress.RowNumber.ToString(), ":", LastAddress.RowNumber.ToString()); + { + address = string.Concat(FirstAddress.RowNumber.ToString(), ":", LastAddress.RowNumber.ToString()); + } else if (IsEntireColumn()) - address = String.Concat(FirstAddress.ColumnLetter, ":", LastAddress.ColumnLetter); + { + address = string.Concat(FirstAddress.ColumnLetter, ":", LastAddress.ColumnLetter); + } else - address = String.Concat(FirstAddress.ToStringRelative(), ":", LastAddress.ToStringRelative()); + { + address = string.Concat(FirstAddress.ToStringRelative(), ":", LastAddress.ToStringRelative()); + } } if (includeSheet || WorksheetIsDeleted) - return String.Concat( + { + return string.Concat( WorksheetIsDeleted ? "#REF" : Worksheet.Name.EscapeSheetName(), "!", address); + } return address; } - public String ToStringFixed(XLReferenceStyle referenceStyle) + public string ToStringFixed(XLReferenceStyle referenceStyle) { return ToStringFixed(referenceStyle, false); } - public String ToStringFixed(XLReferenceStyle referenceStyle, Boolean includeSheet) + public string ToStringFixed(XLReferenceStyle referenceStyle, bool includeSheet) { string address; if (!IsValid) + { address = "#REF!"; + } else { if (IsEntireSheet()) + { address = $"$1:${XLHelper.MaxRowNumber}"; + } else if (IsEntireRow()) - address = String.Concat("$", FirstAddress.RowNumber.ToString(), ":$", LastAddress.RowNumber.ToString()); + { + address = string.Concat("$", FirstAddress.RowNumber.ToString(), ":$", LastAddress.RowNumber.ToString()); + } else if (IsEntireColumn()) - address = String.Concat("$", FirstAddress.ColumnLetter, ":$", LastAddress.ColumnLetter); + { + address = string.Concat("$", FirstAddress.ColumnLetter, ":$", LastAddress.ColumnLetter); + } else - address = String.Concat(FirstAddress.ToStringFixed(referenceStyle), ":", LastAddress.ToStringFixed(referenceStyle)); + { + address = string.Concat(FirstAddress.ToStringFixed(referenceStyle), ":", LastAddress.ToStringFixed(referenceStyle)); + } } if (includeSheet || WorksheetIsDeleted) - return String.Concat( + { + return string.Concat( WorksheetIsDeleted ? "#REF" : Worksheet.Name.EscapeSheetName(), "!", address); + } return address; } @@ -303,15 +329,15 @@ public override string ToString() { var worksheet = WorksheetIsDeleted ? "#REF!" : ""; - var address = (!FirstAddress.IsValid || !LastAddress.IsValid) ? "#REF!" : String.Concat(FirstAddress.ToString(), ":", LastAddress.ToString()); - return String.Concat(worksheet, address); + var address = (!FirstAddress.IsValid || !LastAddress.IsValid) ? "#REF!" : string.Concat(FirstAddress.ToString(), ":", LastAddress.ToString()); + return string.Concat(worksheet, address); } if (IsEntireSheet()) { var worksheet = WorksheetIsDeleted ? "#REF!" : ""; var address = $"1:{XLHelper.MaxRowNumber}"; - return String.Concat(worksheet, address); + return string.Concat(worksheet, address); } else if (IsEntireRow()) { @@ -319,7 +345,7 @@ public override string ToString() var firstAddress = FirstAddress.IsValid ? FirstAddress.RowNumber.ToString() : "#REF!"; var lastAddress = LastAddress.IsValid ? LastAddress.RowNumber.ToString() : "#REF!"; - return String.Concat(worksheet, firstAddress, ':', lastAddress); + return string.Concat(worksheet, firstAddress, ':', lastAddress); } else if (IsEntireColumn()) { @@ -327,11 +353,11 @@ public override string ToString() var firstAddress = FirstAddress.IsValid ? FirstAddress.ColumnLetter : "#REF!"; var lastAddress = LastAddress.IsValid ? LastAddress.ColumnLetter : "#REF!"; - return String.Concat(worksheet, firstAddress, ':', lastAddress); + return string.Concat(worksheet, firstAddress, ':', lastAddress); } else { - return String.Concat(FirstAddress.ToString(), ":", LastAddress.ToString()); + return string.Concat(FirstAddress.ToString(), ":", LastAddress.ToString()); } } @@ -343,9 +369,13 @@ public string ToString(XLReferenceStyle referenceStyle) public string ToString(XLReferenceStyle referenceStyle, bool includeSheet) { if (referenceStyle == XLReferenceStyle.R1C1) + { return ToStringFixed(referenceStyle, true); + } else + { return ToStringRelative(includeSheet); + } } public override bool Equals(object obj) @@ -413,16 +443,16 @@ internal XLRangeAddress Relative(in XLRangeAddress sourceRangeAddress, in XLRang new XLAddress ( sheet, - this.FirstAddress.RowNumber - sourceRangeAddress.FirstAddress.RowNumber + targetRangeAddress.FirstAddress.RowNumber, - this.FirstAddress.ColumnNumber - sourceRangeAddress.FirstAddress.ColumnNumber + targetRangeAddress.FirstAddress.ColumnNumber, + FirstAddress.RowNumber - sourceRangeAddress.FirstAddress.RowNumber + targetRangeAddress.FirstAddress.RowNumber, + FirstAddress.ColumnNumber - sourceRangeAddress.FirstAddress.ColumnNumber + targetRangeAddress.FirstAddress.ColumnNumber, fixedRow: false, fixedColumn: false ), new XLAddress ( sheet, - this.LastAddress.RowNumber - sourceRangeAddress.FirstAddress.RowNumber + targetRangeAddress.FirstAddress.RowNumber, - this.LastAddress.ColumnNumber - sourceRangeAddress.FirstAddress.ColumnNumber + targetRangeAddress.FirstAddress.ColumnNumber, + LastAddress.RowNumber - sourceRangeAddress.FirstAddress.RowNumber + targetRangeAddress.FirstAddress.RowNumber, + LastAddress.ColumnNumber - sourceRangeAddress.FirstAddress.ColumnNumber + targetRangeAddress.FirstAddress.ColumnNumber, fixedRow: false, fixedColumn: false ) @@ -432,7 +462,9 @@ internal XLRangeAddress Relative(in XLRangeAddress sourceRangeAddress, in XLRang public IXLRangeAddress Intersection(IXLRangeAddress otherRangeAddress) { if (otherRangeAddress == null) + { throw new ArgumentNullException(nameof(otherRangeAddress)); + } var xlOtherRangeAddress = (XLRangeAddress)otherRangeAddress; return Intersection(in xlOtherRangeAddress); @@ -440,10 +472,12 @@ public IXLRangeAddress Intersection(IXLRangeAddress otherRangeAddress) internal XLRangeAddress Intersection(in XLRangeAddress otherRangeAddress) { - if (!this.Worksheet.Equals(otherRangeAddress.Worksheet)) + if (!Worksheet.Equals(otherRangeAddress.Worksheet)) + { throw new ArgumentOutOfRangeException(nameof(otherRangeAddress), "The other range address is on a different worksheet"); + } - var thisRangeAddressNormalized = this.Normalize(); + var thisRangeAddressNormalized = Normalize(); var otherRangeAddressNormalized = otherRangeAddress.Normalize(); var firstRow = Math.Max(thisRangeAddressNormalized.FirstAddress.RowNumber, otherRangeAddressNormalized.FirstAddress.RowNumber); @@ -452,24 +486,30 @@ internal XLRangeAddress Intersection(in XLRangeAddress otherRangeAddress) var lastColumn = Math.Min(thisRangeAddressNormalized.LastAddress.ColumnNumber, otherRangeAddressNormalized.LastAddress.ColumnNumber); if (lastRow < firstRow || lastColumn < firstColumn) - return XLRangeAddress.Invalid; + { + return Invalid; + } return new XLRangeAddress ( - new XLAddress(this.Worksheet, firstRow, firstColumn, fixedRow: false, fixedColumn: false), - new XLAddress(this.Worksheet, lastRow, lastColumn, fixedRow: false, fixedColumn: false) + new XLAddress(Worksheet, firstRow, firstColumn, fixedRow: false, fixedColumn: false), + new XLAddress(Worksheet, lastRow, lastColumn, fixedRow: false, fixedColumn: false) ); } public IXLRange AsRange() { - if (this.Worksheet == null) + if (Worksheet == null) + { throw new InvalidOperationException("The worksheet of the current range address has not been set."); + } - if (!this.IsValid) + if (!IsValid) + { return null; + } - return this.Worksheet.Range(this); + return Worksheet.Range(this); } #endregion Public methods diff --git a/ClosedXML/Excel/Ranges/XLRangeBase.cs b/ClosedXML/Excel/Ranges/XLRangeBase.cs index 32a5b2608..f7204f3ea 100644 --- a/ClosedXML/Excel/Ranges/XLRangeBase.cs +++ b/ClosedXML/Excel/Ranges/XLRangeBase.cs @@ -1,3 +1,6 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Ranges.Sort; +using ClosedXML.Excel.Style; using System; using System.Collections; using System.Collections.Generic; @@ -23,8 +26,8 @@ protected IXLStyle GetStyle() #region Constructor - private static Int32 IdCounter = 0; - private readonly Int32 Id; + private static int IdCounter; + private readonly int Id; protected XLRangeBase(XLRangeAddress rangeAddress, XLStyleValue styleValue) : base(styleValue) @@ -59,10 +62,7 @@ protected set } } - public XLWorksheet Worksheet - { - get { return RangeAddress.Worksheet; } - } + public XLWorksheet Worksheet => RangeAddress.Worksheet; public IXLDataValidation CreateDataValidation() { @@ -80,17 +80,11 @@ public IXLDataValidation GetDataValidation() #region IXLRangeBase Members - IXLRangeAddress IXLAddressable.RangeAddress - { - get { return RangeAddress; } - } + IXLRangeAddress IXLAddressable.RangeAddress => RangeAddress; - IXLWorksheet IXLRangeBase.Worksheet - { - get { return RangeAddress.Worksheet; } - } + IXLWorksheet IXLRangeBase.Worksheet => RangeAddress.Worksheet; - public String FormulaA1 + public string FormulaA1 { set { @@ -102,7 +96,7 @@ public String FormulaA1 } } - public String FormulaR1C1 + public string FormulaR1C1 { set { @@ -114,7 +108,7 @@ public String FormulaR1C1 } } - public Boolean ShareString + public bool ShareString { set { Cells().ForEach(c => c.ShareString = value); } } @@ -132,7 +126,7 @@ where RangeAddress.Contains(hl.Cell.Address) } } - public Object Value + public object Value { set { Cells().ForEach(c => c.Value = value); } } @@ -160,7 +154,9 @@ protected override IEnumerable Children get { foreach (var cell in Cells().OfType()) + { yield return cell; + } } } @@ -168,8 +164,10 @@ public override IEnumerable Styles { get { - foreach (IXLCell cell in Cells()) + foreach (var cell in Cells()) + { yield return cell.Style; + } } } @@ -206,18 +204,18 @@ IXLCell IXLRangeBase.FirstCellUsed(XLCellsUsedOptions options) return FirstCellUsed(options, null); } - IXLCell IXLRangeBase.FirstCellUsed(Func predicate) + IXLCell IXLRangeBase.FirstCellUsed(Func predicate) { return FirstCellUsed(predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell IXLRangeBase.FirstCellUsed(Boolean includeFormats, Func predicate) + IXLCell IXLRangeBase.FirstCellUsed(bool includeFormats, Func predicate) { return FirstCellUsed(includeFormats, predicate); } - IXLCell IXLRangeBase.FirstCellUsed(XLCellsUsedOptions options, Func predicate) + IXLCell IXLRangeBase.FirstCellUsed(XLCellsUsedOptions options, Func predicate) { return FirstCellUsed(options, predicate); } @@ -239,18 +237,18 @@ IXLCell IXLRangeBase.LastCellUsed(XLCellsUsedOptions options) return LastCellUsed(options, null); } - IXLCell IXLRangeBase.LastCellUsed(Func predicate) + IXLCell IXLRangeBase.LastCellUsed(Func predicate) { return LastCellUsed(predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCell IXLRangeBase.LastCellUsed(Boolean includeFormats, Func predicate) + IXLCell IXLRangeBase.LastCellUsed(bool includeFormats, Func predicate) { return LastCellUsed(includeFormats, predicate); } - IXLCell IXLRangeBase.LastCellUsed(XLCellsUsedOptions options, Func predicate) + IXLCell IXLRangeBase.LastCellUsed(XLCellsUsedOptions options, Func predicate) { return LastCellUsed(options, predicate); } @@ -260,13 +258,13 @@ public virtual IXLCells Cells() return Cells(false); } - public virtual IXLCells Cells(Boolean usedCellsOnly) + public virtual IXLCells Cells(bool usedCellsOnly) { return Cells(usedCellsOnly, XLCellsUsedOptions.AllContents); } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells Cells(Boolean usedCellsOnly, Boolean includeFormats) + public IXLCells Cells(bool usedCellsOnly, bool includeFormats) { return Cells(usedCellsOnly, includeFormats ? XLCellsUsedOptions.All @@ -274,18 +272,18 @@ public IXLCells Cells(Boolean usedCellsOnly, Boolean includeFormats) ); } - public IXLCells Cells(Boolean usedCellsOnly, XLCellsUsedOptions options) + public IXLCells Cells(bool usedCellsOnly, XLCellsUsedOptions options) { var cells = new XLCells(usedCellsOnly, options) { RangeAddress }; return cells; } - public virtual IXLCells Cells(String cells) + public virtual IXLCells Cells(string cells) { return Ranges(cells).Cells(); } - public IXLCells Cells(Func predicate) + public IXLCells Cells(Func predicate) { var cells = new XLCells(false, XLCellsUsedOptions.AllContents, predicate) { RangeAddress }; return cells; @@ -301,9 +299,9 @@ public IXLCells CellsUsed() /// public IEnumerable CellValues() { - for (int ro = RangeAddress.FirstAddress.RowNumber; ro <= RangeAddress.LastAddress.RowNumber; ro++) + for (var ro = RangeAddress.FirstAddress.RowNumber; ro <= RangeAddress.LastAddress.RowNumber; ro++) { - for (int co = RangeAddress.FirstAddress.ColumnNumber; co <= RangeAddress.LastAddress.ColumnNumber; co++) + for (var co = RangeAddress.FirstAddress.ColumnNumber; co <= RangeAddress.LastAddress.ColumnNumber; co++) { yield return Worksheet.GetCellValue(ro, co); } @@ -315,10 +313,12 @@ public IXLRange Merge() return Merge(true); } - public IXLRange Merge(Boolean checkIntersect) + public IXLRange Merge(bool checkIntersect) { if (RangeAddress.FirstAddress.Equals(RangeAddress.LastAddress)) + { return Worksheet.Range(RangeAddress); + } var asRange = AsRange(); @@ -342,37 +342,63 @@ public IXLRange Merge(Boolean checkIntersect) & ~XLClearOptions.NormalFormats)); if (firstCellStyleKey.Alignment != defaultStyleKey.Alignment) + { asRange.Style.Alignment = firstCellStyle.Alignment; + } else + { cellsUsed.ForEach(c => c.Style.Alignment = firstCellStyle.Alignment); + } if (firstCellStyleKey.Fill != defaultStyleKey.Fill) + { asRange.Style.Fill = firstCellStyle.Fill; + } else + { cellsUsed.ForEach(c => c.Style.Fill = firstCellStyle.Fill); + } if (firstCellStyleKey.Font != defaultStyleKey.Font) + { asRange.Style.Font = firstCellStyle.Font; + } else + { cellsUsed.ForEach(c => c.Style.Font = firstCellStyle.Font); + } if (firstCellStyleKey.IncludeQuotePrefix != defaultStyleKey.IncludeQuotePrefix) + { asRange.Style.IncludeQuotePrefix = firstCellStyle.IncludeQuotePrefix; + } else + { cellsUsed.ForEach(c => c.Style.IncludeQuotePrefix = firstCellStyle.IncludeQuotePrefix); + } if (firstCellStyleKey.NumberFormat != defaultStyleKey.NumberFormat) + { asRange.Style.NumberFormat = firstCellStyle.NumberFormat; + } else + { cellsUsed.ForEach(c => c.Style.NumberFormat = firstCellStyle.NumberFormat); + } if (firstCellStyleKey.Protection != defaultStyleKey.Protection) + { asRange.Style.Protection = firstCellStyle.Protection; + } else + { cellsUsed.ForEach(c => c.Style.Protection = firstCellStyle.Protection); + } if (cellsUsed.Any(c => (c.Style as XLStyle).Key.Border != defaultStyleKey.Border)) + { asRange.Style.Border.SetInsideBorder(XLBorderStyleValues.None); + } } Worksheet.Internals.MergedRanges.Add(asRange); @@ -381,10 +407,12 @@ public IXLRange Merge(Boolean checkIntersect) public IXLRange Unmerge() { - string tAddress = RangeAddress.ToString(); + var tAddress = RangeAddress.ToString(); var asRange = AsRange(); if (Worksheet.Internals.MergedRanges.Select(m => m.RangeAddress.ToString()).Any(mAddress => mAddress == tAddress)) + { Worksheet.Internals.MergedRanges.Remove(asRange); + } return asRange; } @@ -404,7 +432,9 @@ public IXLRangeBase Clear(XLClearOptions clearOptions = XLClearOptions.All) } if (clearOptions.HasFlag(XLClearOptions.ConditionalFormats)) + { RemoveConditionalFormatting(); + } if (clearOptions.HasFlag(XLClearOptions.DataValidation)) { @@ -413,10 +443,14 @@ public IXLRangeBase Clear(XLClearOptions clearOptions = XLClearOptions.All) } if (clearOptions.HasFlag(XLClearOptions.MergedRanges)) + { ClearMerged(); + } if (clearOptions.HasFlag(XLClearOptions.Sparklines)) + { RemoveSparklines(); + } if (clearOptions == XLClearOptions.All) { @@ -434,7 +468,7 @@ public IXLRangeBase Relative(IXLRangeBase sourceBaseRange, IXLRangeBase targetBa { var xlSourceBaseRangeAddress = (XLRangeAddress)sourceBaseRange.RangeAddress; var xlTargetBaseRangeAddress = (XLRangeAddress)targetBaseRange.RangeAddress; - var xlRangeAddress = this.RangeAddress.Relative(in xlSourceBaseRangeAddress, in xlTargetBaseRangeAddress); + var xlRangeAddress = RangeAddress.Relative(in xlSourceBaseRangeAddress, in xlTargetBaseRangeAddress); return ((XLRangeBase)targetBaseRange).Range(in xlRangeAddress); } @@ -465,9 +499,14 @@ internal void RemoveConditionalFormatting() if (mf.RowNumber.Between(f.RowNumber, l.RowNumber) || ml.RowNumber.Between(f.RowNumber, l.RowNumber)) { if (mf.RowNumber > f.RowNumber) + { rng1 = Worksheet.Range(f.RowNumber, f.ColumnNumber, mf.RowNumber - 1, l.ColumnNumber); + } + if (ml.RowNumber < l.RowNumber) + { rng2 = Worksheet.Range(ml.RowNumber + 1, f.ColumnNumber, l.RowNumber, l.ColumnNumber); + } } byWidth = true; } @@ -477,9 +516,14 @@ internal void RemoveConditionalFormatting() if (mf.ColumnNumber.Between(f.ColumnNumber, l.ColumnNumber) || ml.ColumnNumber.Between(f.ColumnNumber, l.ColumnNumber)) { if (mf.ColumnNumber > f.ColumnNumber) + { rng1 = Worksheet.Range(f.RowNumber, f.ColumnNumber, l.RowNumber, mf.ColumnNumber - 1); + } + if (ml.ColumnNumber < l.ColumnNumber) + { rng2 = Worksheet.Range(f.RowNumber, ml.ColumnNumber + 1, l.RowNumber, l.ColumnNumber); + } } byHeight = true; } @@ -495,10 +539,14 @@ internal void RemoveConditionalFormatting() } if (!byWidth && !byHeight) + { format.Ranges.Add(cfRange); // Not split, preserve original + } } if (!format.Ranges.Any()) + { Worksheet.ConditionalFormats.Remove(x => x == format); + } } } @@ -513,9 +561,9 @@ public void DeleteComments() Cells().DeleteComments(); } - public bool Contains(String rangeAddress) + public bool Contains(string rangeAddress) { - string addressToUse = rangeAddress.Contains("!") + var addressToUse = rangeAddress.Contains("!") ? rangeAddress.Substring(rangeAddress.IndexOf("!") + 1) : rangeAddress; @@ -548,7 +596,10 @@ public bool Intersects(string rangeAddress) public bool Intersects(IXLRangeBase range) { if (!range.RangeAddress.IsValid || !RangeAddress.IsValid) + { return false; + } + var ma = range.RangeAddress; var ra = RangeAddress; return ra.Intersects(ma); @@ -564,26 +615,30 @@ public virtual XLRange AsRange() return Worksheet.Range(RangeAddress); } - public IXLRange AddToNamed(String rangeName) + public IXLRange AddToNamed(string rangeName) { return AddToNamed(rangeName, XLScope.Workbook); } - public IXLRange AddToNamed(String rangeName, XLScope scope) + public IXLRange AddToNamed(string rangeName, XLScope scope) { return AddToNamed(rangeName, scope, null); } - public IXLRange AddToNamed(String rangeName, XLScope scope, String comment) + public IXLRange AddToNamed(string rangeName, XLScope scope, string comment) { var namedRanges = scope == XLScope.Workbook ? Worksheet.Workbook.NamedRanges : Worksheet.NamedRanges; - if (namedRanges.TryGetValue(rangeName, out IXLNamedRange namedRange)) + if (namedRanges.TryGetValue(rangeName, out var namedRange)) + { namedRange.Add(Worksheet.Workbook, RangeAddress.ToStringFixed(XLReferenceStyle.A1, true)); + } else + { namedRanges.Add(rangeName, RangeAddress.ToStringFixed(XLReferenceStyle.A1, true), comment); + } return AsRange(); } @@ -594,47 +649,47 @@ public IXLRangeBase SetValue(T value) return this; } - public Boolean IsMerged() + public bool IsMerged() { return Cells().Any(c => c.IsMerged()); } - public virtual Boolean IsEmpty() + public virtual bool IsEmpty() { return !CellsUsed().Any() || CellsUsed().Any(c => c.IsEmpty()); } [Obsolete("Use the overload with XLCellsUsedOptions")] - public virtual Boolean IsEmpty(Boolean includeFormats) + public virtual bool IsEmpty(bool includeFormats) { return IsEmpty(includeFormats ? XLCellsUsedOptions.All : XLCellsUsedOptions.AllContents); } - public virtual Boolean IsEmpty(XLCellsUsedOptions options) + public virtual bool IsEmpty(XLCellsUsedOptions options) { return CellsUsed(options).Cast().All(c => c.IsEmpty(options)); } - public virtual Boolean IsEntireRow() + public virtual bool IsEntireRow() { return RangeAddress.IsEntireRow(); } - public virtual Boolean IsEntireColumn() + public virtual bool IsEntireColumn() { return RangeAddress.IsEntireColumn(); } - public Boolean IsEntireSheet() + public bool IsEntireSheet() { return RangeAddress.IsEntireSheet(); } #endregion IXLRangeBase Members - public IXLCells Search(String searchText, CompareOptions compareOptions = CompareOptions.Ordinal, Boolean searchFormulae = false) + public IXLCells Search(string searchText, CompareOptions compareOptions = CompareOptions.Ordinal, bool searchFormulae = false) { var culture = CultureInfo.CurrentCulture; return CellsUsed(XLCellsUsedOptions.AllContents, c => @@ -642,11 +697,15 @@ public IXLCells Search(String searchText, CompareOptions compareOptions = Compar try { if (searchFormulae) + { return c.HasFormula && culture.CompareInfo.IndexOf(c.FormulaA1, searchText, compareOptions) >= 0 || culture.CompareInfo.IndexOf(c.Value.ToString(), searchText, compareOptions) >= 0; + } else + { return culture.CompareInfo.IndexOf(c.GetFormattedString(), searchText, compareOptions) >= 0; + } } catch { @@ -671,18 +730,18 @@ internal XLCell FirstCellUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - internal XLCell FirstCellUsed(Boolean includeFormats) + internal XLCell FirstCellUsed(bool includeFormats) { return FirstCellUsed(includeFormats, null); } - internal XLCell FirstCellUsed(Func predicate) + internal XLCell FirstCellUsed(Func predicate) { return FirstCellUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - internal XLCell FirstCellUsed(Boolean includeFormats, Func predicate) + internal XLCell FirstCellUsed(bool includeFormats, Func predicate) { return FirstCellUsed(includeFormats ? XLCellsUsedOptions.All @@ -690,21 +749,27 @@ internal XLCell FirstCellUsed(Boolean includeFormats, Func pre predicate); } - internal XLCell FirstCellUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLCell FirstCellUsed(XLCellsUsedOptions options, Func predicate = null) { var cellsUsed = CellsUsedInternal(options, r => r.FirstCell(), predicate).ToList(); if (!cellsUsed.Any()) + { return null; + } var firstRow = cellsUsed.Min(c => c.Address.RowNumber); var firstColumn = cellsUsed.Min(c => c.Address.ColumnNumber); if (firstRow < RangeAddress.FirstAddress.RowNumber) + { firstRow = RangeAddress.FirstAddress.RowNumber; + } if (firstColumn < RangeAddress.FirstAddress.ColumnNumber) + { firstColumn = RangeAddress.FirstAddress.ColumnNumber; + } return Worksheet.Cell(firstRow, firstColumn); } @@ -715,18 +780,18 @@ internal XLCell LastCellUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - internal XLCell LastCellUsed(Boolean includeFormats) + internal XLCell LastCellUsed(bool includeFormats) { return LastCellUsed(includeFormats, null); } - internal XLCell LastCellUsed(Func predicate) + internal XLCell LastCellUsed(Func predicate) { return LastCellUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - internal XLCell LastCellUsed(Boolean includeFormats, Func predicate) + internal XLCell LastCellUsed(bool includeFormats, Func predicate) { return LastCellUsed(includeFormats ? XLCellsUsedOptions.All @@ -734,42 +799,52 @@ internal XLCell LastCellUsed(Boolean includeFormats, Func pred predicate); } - internal XLCell LastCellUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLCell LastCellUsed(XLCellsUsedOptions options, Func predicate = null) { var cellsUsed = CellsUsedInternal(options, r => r.LastCell(), predicate).ToList(); if (!cellsUsed.Any()) + { return null; + } var lastRow = cellsUsed.Max(c => c.Address.RowNumber); var lastColumn = cellsUsed.Max(c => c.Address.ColumnNumber); if (lastRow > RangeAddress.LastAddress.RowNumber) + { lastRow = RangeAddress.LastAddress.RowNumber; + } if (lastColumn > RangeAddress.LastAddress.ColumnNumber) + { lastColumn = RangeAddress.LastAddress.ColumnNumber; + } return Worksheet.Cell(lastRow, lastColumn); } - public XLCell Cell(Int32 row, Int32 column) + public XLCell Cell(int row, int column) { return Cell(new XLAddress(Worksheet, row, column, false, false)); } - public virtual XLCell Cell(String cellAddressInRange) + public virtual XLCell Cell(string cellAddressInRange) { if (XLHelper.IsValidA1Address(cellAddressInRange)) + { return Cell(XLAddress.Create(Worksheet, cellAddressInRange)); + } - if (Worksheet.NamedRanges.TryGetValue(cellAddressInRange, out IXLNamedRange namedRange)) + if (Worksheet.NamedRanges.TryGetValue(cellAddressInRange, out var namedRange)) + { return namedRange.Ranges.First().FirstCell().CastTo(); + } return null; } - public XLCell Cell(Int32 row, String column) + public XLCell Cell(int row, string column) { return Cell(new XLAddress(Worksheet, row, column, false, false)); } @@ -781,14 +856,14 @@ public XLCell Cell(IXLAddress cellAddressInRange) public XLCell Cell(in XLAddress cellAddressInRange) { - Int32 absRow = cellAddressInRange.RowNumber + RangeAddress.FirstAddress.RowNumber - 1; - Int32 absColumn = cellAddressInRange.ColumnNumber + RangeAddress.FirstAddress.ColumnNumber - 1; + var absRow = cellAddressInRange.RowNumber + RangeAddress.FirstAddress.RowNumber - 1; + var absColumn = cellAddressInRange.ColumnNumber + RangeAddress.FirstAddress.ColumnNumber - 1; if (absRow <= 0 || absRow > XLHelper.MaxRowNumber) { throw new ArgumentOutOfRangeException( nameof(cellAddressInRange), - String.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber) + string.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber) ); } @@ -796,7 +871,7 @@ public XLCell Cell(in XLAddress cellAddressInRange) { throw new ArgumentOutOfRangeException( nameof(cellAddressInRange), - String.Format("Column number must be between 1 and {0}", XLHelper.MaxColumnNumber) + string.Format("Column number must be between 1 and {0}", XLHelper.MaxColumnNumber) ); } @@ -804,20 +879,26 @@ public XLCell Cell(in XLAddress cellAddressInRange) absColumn); if (cell != null) + { return cell; + } - var styleValue = this.StyleValue; + var styleValue = StyleValue; if (styleValue == Worksheet.StyleValue) { - if (Worksheet.Internals.RowsCollection.TryGetValue(absRow, out XLRow row) + if (Worksheet.Internals.RowsCollection.TryGetValue(absRow, out var row) && row.StyleValue != Worksheet.StyleValue) + { styleValue = row.StyleValue; - else if (Worksheet.Internals.ColumnsCollection.TryGetValue(absColumn, out XLColumn column) + } + else if (Worksheet.Internals.ColumnsCollection.TryGetValue(absColumn, out var column) && column.StyleValue != Worksheet.StyleValue) + { styleValue = column.StyleValue; + } } - var absoluteAddress = new XLAddress(this.Worksheet, + var absoluteAddress = new XLAddress(Worksheet, absRow, absColumn, cellAddressInRange.FixedRow, @@ -825,60 +906,72 @@ public XLCell Cell(in XLAddress cellAddressInRange) // If the default style for this range base is empty, but the worksheet // has a default style, use the worksheet's default style - XLCell newCell = new XLCell(Worksheet, absoluteAddress, styleValue); + var newCell = new XLCell(Worksheet, absoluteAddress, styleValue); Worksheet.Internals.CellsCollection.Add(absRow, absColumn, newCell); return newCell; } - public Int32 RowCount() + public int RowCount() { return RangeAddress.LastAddress.RowNumber - RangeAddress.FirstAddress.RowNumber + 1; } - public Int32 RowCount(XLCellsUsedOptions cellsUsedOptions) + public int RowCount(XLCellsUsedOptions cellsUsedOptions) { var lcu = LastCellUsed(cellsUsedOptions); - if (lcu == null) return 0; + if (lcu == null) + { + return 0; + } var fcu = FirstCellUsed(cellsUsedOptions); - if (fcu == null) return 0; + if (fcu == null) + { + return 0; + } return lcu.Address.RowNumber - fcu.Address.RowNumber + 1; } - public Int32 RowNumber() + public int RowNumber() { return RangeAddress.FirstAddress.RowNumber; } - public Int32 ColumnCount() + public int ColumnCount() { return RangeAddress.LastAddress.ColumnNumber - RangeAddress.FirstAddress.ColumnNumber + 1; } - public Int32 ColumnCount(XLCellsUsedOptions cellsUsedOptions) + public int ColumnCount(XLCellsUsedOptions cellsUsedOptions) { var lcu = LastCellUsed(cellsUsedOptions); - if (lcu == null) return 0; + if (lcu == null) + { + return 0; + } var fcu = FirstCellUsed(cellsUsedOptions); - if (fcu == null) return 0; + if (fcu == null) + { + return 0; + } return lcu.Address.ColumnNumber - fcu.Address.ColumnNumber + 1; } - public Int32 ColumnNumber() + public int ColumnNumber() { return RangeAddress.FirstAddress.ColumnNumber; } - public String ColumnLetter() + public string ColumnLetter() { return RangeAddress.FirstAddress.ColumnLetter; } - public virtual XLRange Range(String rangeAddressStr) + public virtual XLRange Range(string rangeAddressStr) { var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressStr); return Range(rangeAddress); @@ -900,11 +993,15 @@ public XLRange Range(IXLCell firstCell, IXLCell lastCell) private XLRange GetRange(XLAddress newFirstCellAddress, XLAddress newLastCellAddress) { - if (!this.Worksheet.Equals(newFirstCellAddress.Worksheet)) + if (!Worksheet.Equals(newFirstCellAddress.Worksheet)) + { throw new ArgumentException("The address refers to a different worksheet.", nameof(newFirstCellAddress)); + } - if (!this.Worksheet.Equals(newLastCellAddress.Worksheet)) + if (!Worksheet.Equals(newLastCellAddress.Worksheet)) + { throw new ArgumentException("The address refers to a different worksheet.", nameof(newLastCellAddress)); + } var newRangeAddress = new XLRangeAddress(newFirstCellAddress, newLastCellAddress); var xlRangeParameters = new XLRangeParameters(newRangeAddress, Style); @@ -917,7 +1014,7 @@ private XLRange GetRange(XLAddress newFirstCellAddress, XLAddress newLastCellAdd || newLastCellAddress.ColumnNumber > RangeAddress.LastAddress.ColumnNumber ) { - throw new ArgumentOutOfRangeException(String.Format( + throw new ArgumentOutOfRangeException(string.Format( "The cells {0} and {1} are outside the range '{2}'.", newFirstCellAddress, newLastCellAddress, @@ -925,21 +1022,27 @@ private XLRange GetRange(XLAddress newFirstCellAddress, XLAddress newLastCellAdd } if (newFirstCellAddress.Worksheet != null) + { return newFirstCellAddress.Worksheet.GetOrCreateRange(xlRangeParameters); + } else if (Worksheet != null) + { return Worksheet.GetOrCreateRange(xlRangeParameters); + } else + { return new XLRange(xlRangeParameters); + } } - public XLRange Range(String firstCellAddress, String lastCellAddress) + public XLRange Range(string firstCellAddress, string lastCellAddress) { var rangeAddress = new XLRangeAddress(XLAddress.Create(Worksheet, firstCellAddress), XLAddress.Create(Worksheet, lastCellAddress)); return Range(rangeAddress); } - public XLRange Range(Int32 firstCellRow, Int32 firstCellColumn, Int32 lastCellRow, Int32 lastCellColumn) + public XLRange Range(int firstCellRow, int firstCellColumn, int lastCellRow, int lastCellColumn) { var rangeAddress = new XLRangeAddress ( @@ -996,34 +1099,46 @@ internal XLRange Range(in XLRangeAddress rangeAddress) return GetRange(newFirstCellAddress, newLastCellAddress); } - public virtual IXLRanges Ranges(String ranges) + public virtual IXLRanges Ranges(string ranges) { var retVal = new XLRanges(); var rangePairs = ranges.Split(','); - foreach (string pair in rangePairs) + foreach (var pair in rangePairs) + { retVal.Add(Range(pair.Trim())); + } + return retVal; } - public IXLRanges Ranges(params String[] ranges) + public IXLRanges Ranges(params string[] ranges) { var retVal = new XLRanges(); - foreach (string pair in ranges) + foreach (var pair in ranges) + { retVal.Add(Range(pair)); + } + return retVal; } - protected String FixColumnAddress(String address) + protected string FixColumnAddress(string address) { - if (Int32.TryParse(address, out Int32 rowNumber)) + if (int.TryParse(address, out var rowNumber)) + { return RangeAddress.FirstAddress.ColumnLetter + (rowNumber + RangeAddress.FirstAddress.RowNumber - 1).ToInvariantString(); + } + return address; } - protected String FixRowAddress(String address) + protected string FixRowAddress(string address) { - if (Int32.TryParse(address, out Int32 columnNumber)) + if (int.TryParse(address, out var columnNumber)) + { return XLHelper.GetColumnLetterFromNumber(columnNumber + RangeAddress.FirstAddress.ColumnNumber - 1) + RangeAddress.FirstAddress.RowNumber.ToInvariantString(); + } + return address; } @@ -1041,14 +1156,14 @@ public IXLCells CellsUsed(XLCellsUsedOptions options) return cells; } - public IXLCells CellsUsed(Func predicate) + public IXLCells CellsUsed(Func predicate) { var cells = new XLCells(true, XLCellsUsedOptions.AllContents, predicate) { RangeAddress }; return cells; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells CellsUsed(Boolean includeFormats, Func predicate) + public IXLCells CellsUsed(bool includeFormats, Func predicate) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -1056,18 +1171,18 @@ public IXLCells CellsUsed(Boolean includeFormats, Func predica predicate); } - public IXLCells CellsUsed(XLCellsUsedOptions options, Func predicate) + public IXLCells CellsUsed(XLCellsUsedOptions options, Func predicate) { var cells = new XLCells(true, options, predicate) { RangeAddress }; return cells; } - public IXLRangeColumns InsertColumnsAfter(Int32 numberOfColumns) + public IXLRangeColumns InsertColumnsAfter(int numberOfColumns) { return InsertColumnsAfter(numberOfColumns, true); } - public IXLRangeColumns InsertColumnsAfter(Int32 numberOfColumns, Boolean expandRange) + public IXLRangeColumns InsertColumnsAfter(int numberOfColumns, bool expandRange) { var retVal = InsertColumnsAfter(false, numberOfColumns); // Adjust the range @@ -1088,41 +1203,48 @@ public IXLRangeColumns InsertColumnsAfter(Int32 numberOfColumns, Boolean expandR return retVal; } - public IXLRangeColumns InsertColumnsAfter(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true) + public IXLRangeColumns InsertColumnsAfter(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true) { return InsertColumnsAfterInternal(onlyUsedCells, numberOfColumns, formatFromLeft); } - public void InsertColumnsAfterVoid(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true) + public void InsertColumnsAfterVoid(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true) { InsertColumnsAfterInternal(onlyUsedCells, numberOfColumns, formatFromLeft, nullReturn: true); } - private IXLRangeColumns InsertColumnsAfterInternal(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true, Boolean nullReturn = false) + private IXLRangeColumns InsertColumnsAfterInternal(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true, bool nullReturn = false) { - int columnCount = ColumnCount(); - int firstColumn = RangeAddress.FirstAddress.ColumnNumber + columnCount; + var columnCount = ColumnCount(); + var firstColumn = RangeAddress.FirstAddress.ColumnNumber + columnCount; if (firstColumn > XLHelper.MaxColumnNumber) + { firstColumn = XLHelper.MaxColumnNumber; - int lastColumn = firstColumn + ColumnCount() - 1; + } + + var lastColumn = firstColumn + ColumnCount() - 1; if (lastColumn > XLHelper.MaxColumnNumber) + { lastColumn = XLHelper.MaxColumnNumber; + } - int firstRow = RangeAddress.FirstAddress.RowNumber; - int lastRow = firstRow + RowCount() - 1; + var firstRow = RangeAddress.FirstAddress.RowNumber; + var lastRow = firstRow + RowCount() - 1; if (lastRow > XLHelper.MaxRowNumber) + { lastRow = XLHelper.MaxRowNumber; + } var newRange = Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); return newRange.InsertColumnsBeforeInternal(onlyUsedCells, numberOfColumns, formatFromLeft, nullReturn); } - public IXLRangeColumns InsertColumnsBefore(Int32 numberOfColumns) + public IXLRangeColumns InsertColumnsBefore(int numberOfColumns) { return InsertColumnsBefore(numberOfColumns, false); } - public IXLRangeColumns InsertColumnsBefore(Int32 numberOfColumns, Boolean expandRange) + public IXLRangeColumns InsertColumnsBefore(int numberOfColumns, bool expandRange) { var retVal = InsertColumnsBefore(false, numberOfColumns); // Adjust the range @@ -1143,58 +1265,67 @@ public IXLRangeColumns InsertColumnsBefore(Int32 numberOfColumns, Boolean expand return retVal; } - public IXLRangeColumns InsertColumnsBefore(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true) + public IXLRangeColumns InsertColumnsBefore(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true) { return InsertColumnsBeforeInternal(onlyUsedCells, numberOfColumns, formatFromLeft); } - public void InsertColumnsBeforeVoid(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true) + public void InsertColumnsBeforeVoid(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true) { InsertColumnsBeforeInternal(onlyUsedCells, numberOfColumns, formatFromLeft, nullReturn: true); } - private IXLRangeColumns InsertColumnsBeforeInternal(Boolean onlyUsedCells, Int32 numberOfColumns, Boolean formatFromLeft = true, Boolean nullReturn = false) + private IXLRangeColumns InsertColumnsBeforeInternal(bool onlyUsedCells, int numberOfColumns, bool formatFromLeft = true, bool nullReturn = false) { if (numberOfColumns <= 0 || numberOfColumns > XLHelper.MaxColumnNumber) + { throw new ArgumentOutOfRangeException(nameof(numberOfColumns), $"Number of columns to insert must be a positive number no more than {XLHelper.MaxColumnNumber}"); + } - foreach (XLWorksheet ws in Worksheet.Workbook.WorksheetsInternal) + foreach (var ws in Worksheet.Workbook.WorksheetsInternal) { - foreach (XLCell cell in ws.Internals.CellsCollection.GetCells(c => !String.IsNullOrWhiteSpace(c.FormulaA1))) + foreach (var cell in ws.Internals.CellsCollection.GetCells(c => !string.IsNullOrWhiteSpace(c.FormulaA1))) + { cell.ShiftFormulaColumns(AsRange(), numberOfColumns); + } } var cellsToInsert = new Dictionary(); var cellsToDelete = new List(); - int firstColumn = RangeAddress.FirstAddress.ColumnNumber; - int firstRow = RangeAddress.FirstAddress.RowNumber; - int lastRow = RangeAddress.FirstAddress.RowNumber + RowCount() - 1; + var firstColumn = RangeAddress.FirstAddress.ColumnNumber; + var firstRow = RangeAddress.FirstAddress.RowNumber; + var lastRow = RangeAddress.FirstAddress.RowNumber + RowCount() - 1; if (!onlyUsedCells) { - int lastColumn = Worksheet.Internals.CellsCollection.MaxColumnUsed; + var lastColumn = Worksheet.Internals.CellsCollection.MaxColumnUsed; if (lastColumn > 0) { - for (int co = lastColumn; co >= firstColumn; co--) + for (var co = lastColumn; co >= firstColumn; co--) { - int newColumn = co + numberOfColumns; - for (int ro = lastRow; ro >= firstRow; ro--) + var newColumn = co + numberOfColumns; + for (var ro = lastRow; ro >= firstRow; ro--) { var oldCell = Worksheet.Internals.CellsCollection.GetCell(ro, co); if (oldCell == null) + { continue; + } var oldKey = new XLAddress(Worksheet, ro, co, false, false); var newKey = new XLAddress(Worksheet, ro, newColumn, false, false); oldCell.Address = newKey; if (newKey.IsValid) + { cellsToInsert.Add(newKey, oldCell); + } + cellsToDelete.Add(oldKey); } - if (this.IsEntireColumn()) + if (IsEntireColumn()) { Worksheet.Column(newColumn).Width = Worksheet.Column(co).Width; } @@ -1204,17 +1335,19 @@ private IXLRangeColumns InsertColumnsBeforeInternal(Boolean onlyUsedCells, Int32 else { foreach ( - XLCell c in + var c in Worksheet.Internals.CellsCollection.GetCells(firstRow, firstColumn, lastRow, Worksheet.Internals.CellsCollection.MaxColumnUsed)) { - int newColumn = c.Address.ColumnNumber + numberOfColumns; + var newColumn = c.Address.ColumnNumber + numberOfColumns; var newKey = new XLAddress(Worksheet, c.Address.RowNumber, newColumn, false, false); cellsToDelete.Add(c.Address); c.Address = newKey; if (newKey.IsValid) + { cellsToInsert.Add(newKey, c); + } } } @@ -1222,10 +1355,10 @@ XLCell c in cellsToInsert.ForEach( c => Worksheet.Internals.CellsCollection.Add(c.Key.RowNumber, c.Key.ColumnNumber, c.Value)); - Int32 firstRowReturn = RangeAddress.FirstAddress.RowNumber; - Int32 lastRowReturn = RangeAddress.LastAddress.RowNumber; - Int32 firstColumnReturn = RangeAddress.FirstAddress.ColumnNumber; - Int32 lastColumnReturn = RangeAddress.FirstAddress.ColumnNumber + numberOfColumns - 1; + var firstRowReturn = RangeAddress.FirstAddress.RowNumber; + var lastRowReturn = RangeAddress.LastAddress.RowNumber; + var firstColumnReturn = RangeAddress.FirstAddress.ColumnNumber; + var lastColumnReturn = RangeAddress.FirstAddress.ColumnNumber + numberOfColumns - 1; Worksheet.NotifyRangeShiftedColumns(AsRange(), numberOfColumns); @@ -1244,11 +1377,11 @@ XLCell c in var modelLastRow = (model as IXLRangeBase).LastCellUsed(contentFlags); if (modelLastRow != null) { - Int32 firstRoReturned = modelFirstRow.Address.RowNumber + var firstRoReturned = modelFirstRow.Address.RowNumber - model.RangeAddress.FirstAddress.RowNumber + 1; - Int32 lastRoReturned = modelLastRow.Address.RowNumber + var lastRoReturned = modelLastRow.Address.RowNumber - model.RangeAddress.FirstAddress.RowNumber + 1; - for (Int32 ro = firstRoReturned; ro <= lastRoReturned; ro++) + for (var ro = firstRoReturned; ro <= lastRoReturned; ro++) { rangeToReturn.Row(ro).Style = model.Cell(ro).Style; } @@ -1259,11 +1392,11 @@ XLCell c in var lastRoUsed = rangeToReturn.LastRowUsed(contentFlags); if (lastRoUsed != null) { - Int32 lastRoReturned = lastRoUsed.RowNumber(); - for (Int32 ro = 1; ro <= lastRoReturned; ro++) + var lastRoReturned = lastRoUsed.RowNumber(); + for (var ro = 1; ro <= lastRoReturned; ro++) { var styleToUse = - Worksheet.Internals.RowsCollection.TryGetValue(ro, out XLRow row) + Worksheet.Internals.RowsCollection.TryGetValue(ro, out var row) ? row.Style : Worksheet.Style; @@ -1273,17 +1406,19 @@ XLCell c in } if (nullReturn) + { return null; + } return rangeToReturn.Columns(); } - public IXLRangeRows InsertRowsBelow(Int32 numberOfRows) + public IXLRangeRows InsertRowsBelow(int numberOfRows) { return InsertRowsBelow(numberOfRows, true); } - public IXLRangeRows InsertRowsBelow(Int32 numberOfRows, Boolean expandRange) + public IXLRangeRows InsertRowsBelow(int numberOfRows, bool expandRange) { var retVal = InsertRowsBelow(false, numberOfRows); // Adjust the range @@ -1304,41 +1439,48 @@ public IXLRangeRows InsertRowsBelow(Int32 numberOfRows, Boolean expandRange) return retVal; } - public IXLRangeRows InsertRowsBelow(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove = true) + public IXLRangeRows InsertRowsBelow(bool onlyUsedCells, int numberOfRows, bool formatFromAbove = true) { return InsertRowsBelowInternal(onlyUsedCells, numberOfRows, formatFromAbove, nullReturn: false); } - public void InsertRowsBelowVoid(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove = true) + public void InsertRowsBelowVoid(bool onlyUsedCells, int numberOfRows, bool formatFromAbove = true) { InsertRowsBelowInternal(onlyUsedCells, numberOfRows, formatFromAbove, nullReturn: true); } - private IXLRangeRows InsertRowsBelowInternal(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove, Boolean nullReturn) + private IXLRangeRows InsertRowsBelowInternal(bool onlyUsedCells, int numberOfRows, bool formatFromAbove, bool nullReturn) { - int rowCount = RowCount(); - int firstRow = RangeAddress.FirstAddress.RowNumber + rowCount; + var rowCount = RowCount(); + var firstRow = RangeAddress.FirstAddress.RowNumber + rowCount; if (firstRow > XLHelper.MaxRowNumber) + { firstRow = XLHelper.MaxRowNumber; - int lastRow = firstRow + RowCount() - 1; + } + + var lastRow = firstRow + RowCount() - 1; if (lastRow > XLHelper.MaxRowNumber) + { lastRow = XLHelper.MaxRowNumber; + } - int firstColumn = RangeAddress.FirstAddress.ColumnNumber; - int lastColumn = firstColumn + ColumnCount() - 1; + var firstColumn = RangeAddress.FirstAddress.ColumnNumber; + var lastColumn = firstColumn + ColumnCount() - 1; if (lastColumn > XLHelper.MaxColumnNumber) + { lastColumn = XLHelper.MaxColumnNumber; + } var newRange = Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); return newRange.InsertRowsAboveInternal(onlyUsedCells, numberOfRows, formatFromAbove, nullReturn); } - public IXLRangeRows InsertRowsAbove(Int32 numberOfRows) + public IXLRangeRows InsertRowsAbove(int numberOfRows) { return InsertRowsAbove(numberOfRows, false); } - public IXLRangeRows InsertRowsAbove(Int32 numberOfRows, Boolean expandRange) + public IXLRangeRows InsertRowsAbove(int numberOfRows, bool expandRange) { var retVal = InsertRowsAbove(false, numberOfRows); // Adjust the range @@ -1359,61 +1501,70 @@ public IXLRangeRows InsertRowsAbove(Int32 numberOfRows, Boolean expandRange) return retVal; } - public void InsertRowsAboveVoid(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove = true) + public void InsertRowsAboveVoid(bool onlyUsedCells, int numberOfRows, bool formatFromAbove = true) { InsertRowsAboveInternal(onlyUsedCells, numberOfRows, formatFromAbove, nullReturn: true); } - public IXLRangeRows InsertRowsAbove(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove = true) + public IXLRangeRows InsertRowsAbove(bool onlyUsedCells, int numberOfRows, bool formatFromAbove = true) { return InsertRowsAboveInternal(onlyUsedCells, numberOfRows, formatFromAbove, nullReturn: false); } - private IXLRangeRows InsertRowsAboveInternal(Boolean onlyUsedCells, Int32 numberOfRows, Boolean formatFromAbove, Boolean nullReturn) + private IXLRangeRows InsertRowsAboveInternal(bool onlyUsedCells, int numberOfRows, bool formatFromAbove, bool nullReturn) { if (numberOfRows <= 0 || numberOfRows > XLHelper.MaxRowNumber) + { throw new ArgumentOutOfRangeException(nameof(numberOfRows), $"Number of rows to insert must be a positive number no more than {XLHelper.MaxRowNumber}"); + } var asRange = AsRange(); - foreach (XLWorksheet ws in Worksheet.Workbook.WorksheetsInternal) + foreach (var ws in Worksheet.Workbook.WorksheetsInternal) { - foreach (XLCell cell in ws.Internals.CellsCollection.GetCells(c => !String.IsNullOrWhiteSpace(c.FormulaA1))) + foreach (var cell in ws.Internals.CellsCollection.GetCells(c => !string.IsNullOrWhiteSpace(c.FormulaA1))) + { cell.ShiftFormulaRows(asRange, numberOfRows); + } } var cellsToInsert = new Dictionary(); var cellsToDelete = new List(); - int firstRow = RangeAddress.FirstAddress.RowNumber; - int firstColumn = RangeAddress.FirstAddress.ColumnNumber; - int lastColumn = Math.Min( + var firstRow = RangeAddress.FirstAddress.RowNumber; + var firstColumn = RangeAddress.FirstAddress.ColumnNumber; + var lastColumn = Math.Min( RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1, Worksheet.Internals.CellsCollection.MaxColumnUsed); if (!onlyUsedCells) { - int lastRow = Worksheet.Internals.CellsCollection.MaxRowUsed; + var lastRow = Worksheet.Internals.CellsCollection.MaxRowUsed; if (lastRow > 0) { - for (int ro = lastRow; ro >= firstRow; ro--) + for (var ro = lastRow; ro >= firstRow; ro--) { - int newRow = ro + numberOfRows; + var newRow = ro + numberOfRows; - for (int co = lastColumn; co >= firstColumn; co--) + for (var co = lastColumn; co >= firstColumn; co--) { var oldCell = Worksheet.Internals.CellsCollection.GetCell(ro, co); if (oldCell == null) + { continue; + } var oldKey = new XLAddress(Worksheet, ro, co, false, false); var newKey = new XLAddress(Worksheet, newRow, co, false, false); oldCell.Address = newKey; if (newKey.IsValid) + { cellsToInsert.Add(newKey, oldCell); + } + cellsToDelete.Add(oldKey); } - if (this.IsEntireRow()) + if (IsEntireRow()) { Worksheet.Row(newRow).Height = Worksheet.Row(ro).Height; } @@ -1423,27 +1574,29 @@ private IXLRangeRows InsertRowsAboveInternal(Boolean onlyUsedCells, Int32 number else { foreach ( - XLCell c in + var c in Worksheet.Internals.CellsCollection.GetCells(firstRow, firstColumn, Worksheet.Internals.CellsCollection.MaxRowUsed, lastColumn)) { - int newRow = c.Address.RowNumber + numberOfRows; + var newRow = c.Address.RowNumber + numberOfRows; var newKey = new XLAddress(Worksheet, newRow, c.Address.ColumnNumber, false, false); cellsToDelete.Add(c.Address); c.Address = newKey; if (newKey.IsValid) + { cellsToInsert.Add(newKey, c); + } } } cellsToDelete.ForEach(c => Worksheet.Internals.CellsCollection.Remove(c.RowNumber, c.ColumnNumber)); cellsToInsert.ForEach(c => Worksheet.Internals.CellsCollection.Add(c.Key.RowNumber, c.Key.ColumnNumber, c.Value)); - Int32 firstRowReturn = RangeAddress.FirstAddress.RowNumber; - Int32 lastRowReturn = RangeAddress.FirstAddress.RowNumber + numberOfRows - 1; - Int32 firstColumnReturn = RangeAddress.FirstAddress.ColumnNumber; - Int32 lastColumnReturn = RangeAddress.LastAddress.ColumnNumber; + var firstRowReturn = RangeAddress.FirstAddress.RowNumber; + var lastRowReturn = RangeAddress.FirstAddress.RowNumber + numberOfRows - 1; + var firstColumnReturn = RangeAddress.FirstAddress.ColumnNumber; + var lastColumnReturn = RangeAddress.LastAddress.ColumnNumber; Worksheet.NotifyRangeShiftedRows(AsRange(), numberOfRows); @@ -1462,11 +1615,11 @@ XLCell c in var modelLastColumn = (model as IXLRangeBase).LastCellUsed(contentFlags); if (modelFirstColumn != null && modelLastColumn != null) { - Int32 firstCoReturned = modelFirstColumn.Address.ColumnNumber + var firstCoReturned = modelFirstColumn.Address.ColumnNumber - model.RangeAddress.FirstAddress.ColumnNumber + 1; - Int32 lastCoReturned = modelLastColumn.Address.ColumnNumber + var lastCoReturned = modelLastColumn.Address.ColumnNumber - model.RangeAddress.FirstAddress.ColumnNumber + 1; - for (Int32 co = firstCoReturned; co <= lastCoReturned; co++) + for (var co = firstCoReturned; co <= lastCoReturned; co++) { rangeToReturn.Column(co).Style = model.Cell(co).Style; } @@ -1477,11 +1630,11 @@ XLCell c in var lastCoUsed = rangeToReturn.LastColumnUsed(contentFlags); if (lastCoUsed != null) { - Int32 lastCoReturned = lastCoUsed.ColumnNumber(); - for (Int32 co = 1; co <= lastCoReturned; co++) + var lastCoReturned = lastCoUsed.ColumnNumber(); + for (var co = 1; co <= lastCoReturned; co++) { var styleToUse = - Worksheet.Internals.ColumnsCollection.TryGetValue(co, out XLColumn column) + Worksheet.Internals.ColumnsCollection.TryGetValue(co, out var column) ? column.Style : Worksheet.Style; @@ -1492,7 +1645,9 @@ XLCell c in // Skip calling .Rows() for performance reasons if required. if (nullReturn) + { return null; + } return rangeToReturn.Rows(); } @@ -1503,7 +1658,7 @@ private void ClearMerged() mergeToDelete.ForEach(m => Worksheet.Internals.MergedRanges.Remove(m)); } - public Boolean Contains(IXLCell cell) + public bool Contains(IXLCell cell) { return Contains((XLAddress)cell.Address); } @@ -1520,10 +1675,13 @@ public bool Contains(XLAddress address) public void Delete(XLShiftDeletedCells shiftDeleteCells) { - int numberOfRows = RowCount(); - int numberOfColumns = ColumnCount(); + var numberOfRows = RowCount(); + var numberOfColumns = ColumnCount(); - if (!RangeAddress.IsValid) return; + if (!RangeAddress.IsValid) + { + return; + } Worksheet.SparklineGroups.Remove(this); @@ -1544,17 +1702,21 @@ public void Delete(XLShiftDeletedCells shiftDeleteCells) .GetCells(c => c.HasFormula))) { if (shiftDeleteCells == XLShiftDeletedCells.ShiftCellsUp) + { cell.ShiftFormulaRows((XLRange)shiftedRangeFormula, numberOfRows * -1); + } else + { cell.ShiftFormulaColumns((XLRange)shiftedRangeFormula, numberOfColumns * -1); + } } // Range to shift... var cellsToInsert = new Dictionary(); var cellsToDelete = new List(); - Int32 columnModifier = 0; - Int32 rowModifier = 0; + var columnModifier = 0; + var rowModifier = 0; IEnumerable cellsQuery; switch (shiftDeleteCells) { @@ -1598,14 +1760,16 @@ public void Delete(XLShiftDeletedCells shiftDeleteCells) if (newCellAddress.IsValid) { - bool canInsert = shiftDeleteCells == XLShiftDeletedCells.ShiftCellsLeft + var canInsert = shiftDeleteCells == XLShiftDeletedCells.ShiftCellsLeft ? c.Address.ColumnNumber > RangeAddress.LastAddress.ColumnNumber : c.Address.RowNumber > RangeAddress.LastAddress.RowNumber; c.Address = newCellAddress; if (canInsert) + { cellsToInsert.Add(newCellAddress, c); + } } } @@ -1621,16 +1785,20 @@ public void Delete(XLShiftDeletedCells shiftDeleteCells) var shiftedRange = AsRange(); if (shiftDeleteCells == XLShiftDeletedCells.ShiftCellsUp) + { Worksheet.NotifyRangeShiftedRows(shiftedRange, rowModifier * -1); + } else + { Worksheet.NotifyRangeShiftedColumns(shiftedRange, columnModifier * -1); + } Worksheet.DeleteRange(RangeAddress); } public override string ToString() { - return String.Concat( + return string.Concat( Worksheet.Name.EscapeSheetName(), '!', RangeAddress.FirstAddress, @@ -1640,33 +1808,44 @@ public override string ToString() protected IXLRangeAddress ShiftColumns(IXLRangeAddress thisRangeAddress, XLRange shiftedRange, int columnsShifted) { - if (!thisRangeAddress.IsValid || !shiftedRange.RangeAddress.IsValid) return thisRangeAddress; + if (!thisRangeAddress.IsValid || !shiftedRange.RangeAddress.IsValid) + { + return thisRangeAddress; + } - bool allRowsAreCovered = thisRangeAddress.FirstAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber && + var allRowsAreCovered = thisRangeAddress.FirstAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber && thisRangeAddress.LastAddress.RowNumber <= shiftedRange.RangeAddress.LastAddress.RowNumber; if (!allRowsAreCovered) + { return thisRangeAddress; + } - bool shiftLeftBoundary = (columnsShifted > 0 && thisRangeAddress.FirstAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber) || + var shiftLeftBoundary = (columnsShifted > 0 && thisRangeAddress.FirstAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber) || (columnsShifted < 0 && thisRangeAddress.FirstAddress.ColumnNumber > shiftedRange.RangeAddress.FirstAddress.ColumnNumber); - bool shiftRightBoundary = thisRangeAddress.LastAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber; + var shiftRightBoundary = thisRangeAddress.LastAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber; - int newLeftBoundary = thisRangeAddress.FirstAddress.ColumnNumber; + var newLeftBoundary = thisRangeAddress.FirstAddress.ColumnNumber; if (shiftLeftBoundary) { if (newLeftBoundary + columnsShifted > shiftedRange.RangeAddress.FirstAddress.ColumnNumber) + { newLeftBoundary = newLeftBoundary + columnsShifted; + } else + { newLeftBoundary = shiftedRange.RangeAddress.FirstAddress.ColumnNumber; + } } - int newRightBoundary = thisRangeAddress.LastAddress.ColumnNumber; + var newRightBoundary = thisRangeAddress.LastAddress.ColumnNumber; if (shiftRightBoundary) + { newRightBoundary += columnsShifted; + } - bool destroyedByShift = newRightBoundary < newLeftBoundary; + var destroyedByShift = newRightBoundary < newLeftBoundary; var firstAddress = (XLAddress)thisRangeAddress.FirstAddress; var lastAddress = (XLAddress)thisRangeAddress.LastAddress; @@ -1679,51 +1858,66 @@ protected IXLRangeAddress ShiftColumns(IXLRangeAddress thisRangeAddress, XLRange } if (shiftLeftBoundary) + { firstAddress = new XLAddress(Worksheet, thisRangeAddress.FirstAddress.RowNumber, newLeftBoundary, thisRangeAddress.FirstAddress.FixedRow, thisRangeAddress.FirstAddress.FixedColumn); + } if (shiftRightBoundary) + { lastAddress = new XLAddress(Worksheet, thisRangeAddress.LastAddress.RowNumber, newRightBoundary, thisRangeAddress.LastAddress.FixedRow, thisRangeAddress.LastAddress.FixedColumn); + } return new XLRangeAddress(firstAddress, lastAddress); } protected IXLRangeAddress ShiftRows(IXLRangeAddress thisRangeAddress, XLRange shiftedRange, int rowsShifted) { - if (!thisRangeAddress.IsValid || !shiftedRange.RangeAddress.IsValid) return thisRangeAddress; + if (!thisRangeAddress.IsValid || !shiftedRange.RangeAddress.IsValid) + { + return thisRangeAddress; + } - bool allColumnsAreCovered = thisRangeAddress.FirstAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber && + var allColumnsAreCovered = thisRangeAddress.FirstAddress.ColumnNumber >= shiftedRange.RangeAddress.FirstAddress.ColumnNumber && thisRangeAddress.LastAddress.ColumnNumber <= shiftedRange.RangeAddress.LastAddress.ColumnNumber; if (!allColumnsAreCovered) + { return thisRangeAddress; + } - bool shiftTopBoundary = (rowsShifted > 0 && thisRangeAddress.FirstAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber) || + var shiftTopBoundary = (rowsShifted > 0 && thisRangeAddress.FirstAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber) || (rowsShifted < 0 && thisRangeAddress.FirstAddress.RowNumber > shiftedRange.RangeAddress.FirstAddress.RowNumber); - bool shiftBottomBoundary = thisRangeAddress.LastAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber; + var shiftBottomBoundary = thisRangeAddress.LastAddress.RowNumber >= shiftedRange.RangeAddress.FirstAddress.RowNumber; - int newTopBoundary = thisRangeAddress.FirstAddress.RowNumber; + var newTopBoundary = thisRangeAddress.FirstAddress.RowNumber; if (shiftTopBoundary) { if (newTopBoundary + rowsShifted > shiftedRange.RangeAddress.FirstAddress.RowNumber) + { newTopBoundary = newTopBoundary + rowsShifted; + } else + { newTopBoundary = shiftedRange.RangeAddress.FirstAddress.RowNumber; + } } - int newBottomBoundary = thisRangeAddress.LastAddress.RowNumber; + var newBottomBoundary = thisRangeAddress.LastAddress.RowNumber; if (shiftBottomBoundary) + { newBottomBoundary += rowsShifted; + } - bool destroyedByShift = newBottomBoundary < newTopBoundary; + var destroyedByShift = newBottomBoundary < newTopBoundary; var firstAddress = (XLAddress)thisRangeAddress.FirstAddress; var lastAddress = (XLAddress)thisRangeAddress.LastAddress; @@ -1736,18 +1930,22 @@ protected IXLRangeAddress ShiftRows(IXLRangeAddress thisRangeAddress, XLRange sh } if (shiftTopBoundary) + { firstAddress = new XLAddress(Worksheet, newTopBoundary, thisRangeAddress.FirstAddress.ColumnNumber, thisRangeAddress.FirstAddress.FixedRow, thisRangeAddress.FirstAddress.FixedColumn); + } if (shiftBottomBoundary) + { lastAddress = new XLAddress(Worksheet, newBottomBoundary, thisRangeAddress.LastAddress.ColumnNumber, thisRangeAddress.LastAddress.FixedRow, thisRangeAddress.LastAddress.FixedColumn); + } return new XLRangeAddress(firstAddress, lastAddress); } @@ -1769,7 +1967,10 @@ public IXLRange RangeUsed(XLCellsUsedOptions options) { var firstCell = (this as IXLRangeBase).FirstCellUsed(options); if (firstCell == null) + { return null; + } + var lastCell = (this as IXLRangeBase).LastCellUsed(options); return Worksheet.Range(firstCell, lastCell); } @@ -1795,12 +1996,12 @@ public virtual void CopyTo(IXLCell target) // return chart; //} - IXLPivotTable IXLRangeBase.CreatePivotTable(IXLCell targetCell, String name) + IXLPivotTable IXLRangeBase.CreatePivotTable(IXLCell targetCell, string name) { return CreatePivotTable(targetCell, name); } - public XLPivotTable CreatePivotTable(IXLCell targetCell, String name) + public XLPivotTable CreatePivotTable(IXLCell targetCell, string name) { return (XLPivotTable)targetCell.Worksheet.PivotTables.Add(name, targetCell, AsRange()); } @@ -1810,36 +2011,39 @@ public virtual IXLAutoFilter SetAutoFilter() return SetAutoFilter(true); } - public IXLAutoFilter SetAutoFilter(Boolean value) + public IXLAutoFilter SetAutoFilter(bool value) { if (value) + { return Worksheet.AutoFilter.Set(this); + } else + { return Worksheet.AutoFilter.Clear(); + } } #region Sort - public IXLSortElements SortRows - { - get { return _sortRows ?? (_sortRows = new XLSortElements()); } - } + public IXLSortElements SortRows => _sortRows ??= new XLSortElements(); - public IXLSortElements SortColumns - { - get { return _sortColumns ?? (_sortColumns = new XLSortElements()); } - } + public IXLSortElements SortColumns => _sortColumns ??= new XLSortElements(); - private String DefaultSortString() + private string DefaultSortString() { var sb = new StringBuilder(); - Int32 maxColumn = ColumnCount(); + var maxColumn = ColumnCount(); if (maxColumn == XLHelper.MaxColumnNumber) + { maxColumn = (this as IXLRangeBase).LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; - for (int i = 1; i <= maxColumn; i++) + } + + for (var i = 1; i <= maxColumn; i++) { if (sb.Length > 0) + { sb.Append(','); + } sb.Append(i); } @@ -1858,18 +2062,18 @@ public IXLRangeBase Sort() return this; } - public IXLRangeBase Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public IXLRangeBase Sort(string columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { SortColumns.Clear(); - if (String.IsNullOrWhiteSpace(columnsToSortBy)) + if (string.IsNullOrWhiteSpace(columnsToSortBy)) { columnsToSortBy = DefaultSortString(); } - foreach (string coPairTrimmed in columnsToSortBy.Split(',').Select(coPair => coPair.Trim())) + foreach (var coPairTrimmed in columnsToSortBy.Split(',').Select(coPair => coPair.Trim())) { - String coString; - String order; + string coString; + string order; if (coPairTrimmed.Contains(' ')) { var pair = coPairTrimmed.Split(' '); @@ -1882,29 +2086,33 @@ public IXLRangeBase Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortO order = sortOrder == XLSortOrder.Ascending ? "ASC" : "DESC"; } - if (!Int32.TryParse(coString, out Int32 co)) + if (!int.TryParse(coString, out var co)) + { co = XLHelper.GetColumnNumberFromLetter(coString); + } - SortColumns.Add(co, String.Compare(order, "ASC", true) == 0 ? XLSortOrder.Ascending : XLSortOrder.Descending, ignoreBlanks, matchCase); + SortColumns.Add(co, string.Compare(order, "ASC", true, CultureInfo.CurrentCulture) == 0 ? XLSortOrder.Ascending : XLSortOrder.Descending, ignoreBlanks, matchCase); } SortRangeRows(); return this; } - public IXLRangeBase Sort(Int32 columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public IXLRangeBase Sort(int columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { return Sort(columnToSortBy.ToString(), sortOrder, matchCase, ignoreBlanks); } - public IXLRangeBase SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public IXLRangeBase SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { SortRows.Clear(); - Int32 maxColumn = ColumnCount(); + var maxColumn = ColumnCount(); if (maxColumn == XLHelper.MaxColumnNumber) + { maxColumn = (this as IXLRangeBase).LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; + } - for (int i = 1; i <= maxColumn; i++) + for (var i = 1; i <= maxColumn; i++) { SortRows.Add(i, sortOrder, ignoreBlanks, matchCase); } @@ -1917,20 +2125,22 @@ public IXLRangeBase SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascendin private void SortRangeRows() { - Int32 maxRow = RowCount(); + var maxRow = RowCount(); if (maxRow == XLHelper.MaxRowNumber) + { maxRow = (this as IXLRangeBase).LastCellUsed(XLCellsUsedOptions.All).Address.RowNumber; + } SortingRangeRows(1, maxRow); } - private void SwapRows(Int32 row1, Int32 row2) + private void SwapRows(int row1, int row2) { - int row1InWs = RangeAddress.FirstAddress.RowNumber + row1 - 1; - int row2InWs = RangeAddress.FirstAddress.RowNumber + row2 - 1; + var row1InWs = RangeAddress.FirstAddress.RowNumber + row1 - 1; + var row2InWs = RangeAddress.FirstAddress.RowNumber + row2 - 1; - Int32 firstColumn = RangeAddress.FirstAddress.ColumnNumber; - Int32 lastColumn = RangeAddress.LastAddress.ColumnNumber; + var firstColumn = RangeAddress.FirstAddress.ColumnNumber; + var lastColumn = RangeAddress.LastAddress.ColumnNumber; var range1Sp1 = new XLSheetPoint(row1InWs, firstColumn); var range1Sp2 = new XLSheetPoint(row1InWs, lastColumn); @@ -1943,28 +2153,38 @@ private void SwapRows(Int32 row1, Int32 row2) private int SortRangeRows(int begPoint, int endPoint) { - int pivot = begPoint; - int m = begPoint + 1; - int n = endPoint; + var pivot = begPoint; + var m = begPoint + 1; + var n = endPoint; while ((m < endPoint) && RowQuick(pivot).CompareTo(RowQuick(m), SortColumns) >= 0) + { m++; + } while (n > begPoint && RowQuick(pivot).CompareTo(RowQuick(n), SortColumns) <= 0) + { n--; + } while (m < n) { SwapRows(m, n); while (m < endPoint && RowQuick(pivot).CompareTo(RowQuick(m), SortColumns) >= 0) + { m++; + } while (n > begPoint && RowQuick(pivot).CompareTo(RowQuick(n), SortColumns) <= 0) + { n--; + } } if (pivot != n) + { SwapRows(n, pivot); + } return n; } @@ -1972,12 +2192,20 @@ private int SortRangeRows(int begPoint, int endPoint) private void SortingRangeRows(int beg, int end) { if (beg == end) + { return; - int pivot = SortRangeRows(beg, end); + } + + var pivot = SortRangeRows(beg, end); if (pivot > beg) + { SortingRangeRows(beg, pivot - 1); + } + if (pivot < end) + { SortingRangeRows(pivot + 1, end); + } } #endregion Sort Rows @@ -1986,19 +2214,22 @@ private void SortingRangeRows(int beg, int end) private void SortRangeColumns() { - Int32 maxColumn = ColumnCount(); + var maxColumn = ColumnCount(); if (maxColumn == XLHelper.MaxColumnNumber) + { maxColumn = (this as IXLRangeBase).LastCellUsed(XLCellsUsedOptions.All).Address.ColumnNumber; + } + SortingRangeColumns(1, maxColumn); } - private void SwapColumns(Int32 column1, Int32 column2) + private void SwapColumns(int column1, int column2) { - int col1InWs = RangeAddress.FirstAddress.ColumnNumber + column1 - 1; - int col2InWs = RangeAddress.FirstAddress.ColumnNumber + column2 - 1; + var col1InWs = RangeAddress.FirstAddress.ColumnNumber + column1 - 1; + var col2InWs = RangeAddress.FirstAddress.ColumnNumber + column2 - 1; - Int32 firstRow = RangeAddress.FirstAddress.RowNumber; - Int32 lastRow = RangeAddress.LastAddress.RowNumber; + var firstRow = RangeAddress.FirstAddress.RowNumber; + var lastRow = RangeAddress.LastAddress.RowNumber; var range1Sp1 = new XLSheetPoint(firstRow, col1InWs); var range1Sp2 = new XLSheetPoint(lastRow, col1InWs); @@ -2011,45 +2242,65 @@ private void SwapColumns(Int32 column1, Int32 column2) private int SortRangeColumns(int begPoint, int endPoint) { - int pivot = begPoint; - int m = begPoint + 1; - int n = endPoint; - while ((m < endPoint) && ColumnQuick(pivot).CompareTo((ColumnQuick(m)), SortRows) >= 0) + var pivot = begPoint; + var m = begPoint + 1; + var n = endPoint; + while ((m < endPoint) && ColumnQuick(pivot).CompareTo(ColumnQuick(m), SortRows) >= 0) + { m++; + } - while ((n > begPoint) && ((ColumnQuick(pivot)).CompareTo((ColumnQuick(n)), SortRows) <= 0)) + while ((n > begPoint) && (ColumnQuick(pivot).CompareTo(ColumnQuick(n), SortRows) <= 0)) + { n--; + } + while (m < n) { SwapColumns(m, n); - while ((m < endPoint) && (ColumnQuick(pivot)).CompareTo((ColumnQuick(m)), SortRows) >= 0) + while ((m < endPoint) && ColumnQuick(pivot).CompareTo(ColumnQuick(m), SortRows) >= 0) + { m++; + } - while ((n > begPoint) && (ColumnQuick(pivot)).CompareTo((ColumnQuick(n)), SortRows) <= 0) + while ((n > begPoint) && ColumnQuick(pivot).CompareTo(ColumnQuick(n), SortRows) <= 0) + { n--; + } } if (pivot != n) + { SwapColumns(n, pivot); + } + return n; } private void SortingRangeColumns(int beg, int end) { if (end == beg) + { return; - int pivot = SortRangeColumns(beg, end); + } + + var pivot = SortRangeColumns(beg, end); if (pivot > beg) + { SortingRangeColumns(beg, pivot - 1); + } + if (pivot < end) + { SortingRangeColumns(pivot + 1, end); + } } #endregion Sort Columns #endregion Sort - public XLRangeColumn ColumnQuick(Int32 column) + public XLRangeColumn ColumnQuick(int column) { var firstCellAddress = new XLAddress(Worksheet, RangeAddress.FirstAddress.RowNumber, @@ -2064,7 +2315,7 @@ public XLRangeColumn ColumnQuick(Int32 column) return Worksheet.RangeColumn(new XLRangeAddress(firstCellAddress, lastCellAddress)); } - public XLRangeRow RowQuick(Int32 row) + public XLRangeRow RowQuick(int row) { var firstCellAddress = new XLAddress(Worksheet, RangeAddress.FirstAddress.RowNumber + row - 1, @@ -2085,15 +2336,19 @@ public IXLDataValidation SetDataValidation() { var existingValidation = GetDataValidation(); if (existingValidation != null && existingValidation.Ranges.Any(r => r == this)) + { return existingValidation; + } - IXLDataValidation dataValidationToCopy = Worksheet.DataValidations.GetAllInRange(RangeAddress) + var dataValidationToCopy = Worksheet.DataValidations.GetAllInRange(RangeAddress) .FirstOrDefault(); var newRange = AsRange(); var dataValidation = new XLDataValidation(newRange); if (dataValidationToCopy != null) + { dataValidation.CopyFrom(dataValidationToCopy); + } Worksheet.DataValidations.Add(dataValidation); return dataValidation; @@ -2126,13 +2381,13 @@ public IXLRangeBase Grow() public IXLRangeBase Grow(int growCount) { - var firstRow = Math.Max(1, this.RangeAddress.FirstAddress.RowNumber - growCount); - var firstColumn = Math.Max(1, this.RangeAddress.FirstAddress.ColumnNumber - growCount); + var firstRow = Math.Max(1, RangeAddress.FirstAddress.RowNumber - growCount); + var firstColumn = Math.Max(1, RangeAddress.FirstAddress.ColumnNumber - growCount); - var lastRow = Math.Min(XLHelper.MaxRowNumber, this.RangeAddress.LastAddress.RowNumber + growCount); - var lastColumn = Math.Min(XLHelper.MaxColumnNumber, this.RangeAddress.LastAddress.ColumnNumber + growCount); + var lastRow = Math.Min(XLHelper.MaxRowNumber, RangeAddress.LastAddress.RowNumber + growCount); + var lastColumn = Math.Min(XLHelper.MaxColumnNumber, RangeAddress.LastAddress.ColumnNumber + growCount); - return this.Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); + return Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); } public IXLRangeBase Shrink() @@ -2142,40 +2397,48 @@ public IXLRangeBase Shrink() public IXLRangeBase Shrink(int shrinkCount) { - var firstRow = this.RangeAddress.FirstAddress.RowNumber + shrinkCount; - var firstColumn = this.RangeAddress.FirstAddress.ColumnNumber + shrinkCount; + var firstRow = RangeAddress.FirstAddress.RowNumber + shrinkCount; + var firstColumn = RangeAddress.FirstAddress.ColumnNumber + shrinkCount; - var lastRow = this.RangeAddress.LastAddress.RowNumber - shrinkCount; - var lastColumn = this.RangeAddress.LastAddress.ColumnNumber - shrinkCount; + var lastRow = RangeAddress.LastAddress.RowNumber - shrinkCount; + var lastColumn = RangeAddress.LastAddress.ColumnNumber - shrinkCount; if (firstRow > lastRow || firstColumn > lastColumn) + { return null; + } - return this.Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); + return Worksheet.Range(firstRow, firstColumn, lastRow, lastColumn); } - public IXLRangeAddress Intersection(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) + public IXLRangeAddress Intersection(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) { if (otherRange == null) + { return null; + } - if (!this.Worksheet.Equals(otherRange.Worksheet)) + if (!Worksheet.Equals(otherRange.Worksheet)) + { return null; + } if (thisRangePredicate == null && otherRangePredicate == null) { // Special case, no predicates. We can optimise this a bit then. - return this.RangeAddress.Intersection(otherRange.RangeAddress); + return RangeAddress.Intersection(otherRange.RangeAddress); } else { thisRangePredicate = thisRangePredicate ?? (c => true); otherRangePredicate = otherRangePredicate ?? (c => true); - var intersectionCells = this.Cells(c => thisRangePredicate(c) && otherRange.Cells(otherRangePredicate).Contains(c)); + var intersectionCells = Cells(c => thisRangePredicate(c) && otherRange.Cells(otherRangePredicate).Contains(c)); if (!intersectionCells.Any()) + { return null; + } var firstRow = intersectionCells.Min(c => c.Address.RowNumber); var firstColumn = intersectionCells.Min(c => c.Address.ColumnNumber); @@ -2185,48 +2448,70 @@ public IXLRangeAddress Intersection(IXLRangeBase otherRange, Func predicate = null) + public IXLCells SurroundingCells(Func predicate = null) { var cells = new XLCells(false, XLCellsUsedOptions.AllContents, predicate); - this.Grow().Cells(c => !this.Contains(c)).ForEach(c => cells.Add(c as XLCell)); + Grow().Cells(c => !Contains(c)).ForEach(c => cells.Add(c as XLCell)); return cells; } - public IXLCells Union(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) + public IXLCells Union(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) { if (otherRange == null) - return this.Cells(thisRangePredicate); + { + return Cells(thisRangePredicate); + } var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - if (!this.Worksheet.Equals(otherRange.Worksheet)) + if (!Worksheet.Equals(otherRange.Worksheet)) + { return cells; + } - if (thisRangePredicate == null) thisRangePredicate = c => true; - if (otherRangePredicate == null) otherRangePredicate = c => true; + if (thisRangePredicate == null) + { + thisRangePredicate = c => true; + } - this.Cells(thisRangePredicate).Concat(otherRange.Cells(otherRangePredicate)).Distinct().ForEach(c => cells.Add(c as XLCell)); + if (otherRangePredicate == null) + { + otherRangePredicate = c => true; + } + + Cells(thisRangePredicate).Concat(otherRange.Cells(otherRangePredicate)).Distinct().ForEach(c => cells.Add(c as XLCell)); return cells; } - public IXLCells Difference(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) + public IXLCells Difference(IXLRangeBase otherRange, Func thisRangePredicate = null, Func otherRangePredicate = null) { if (otherRange == null) - return this.Cells(thisRangePredicate); + { + return Cells(thisRangePredicate); + } var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - if (!this.Worksheet.Equals(otherRange.Worksheet)) + if (!Worksheet.Equals(otherRange.Worksheet)) + { return cells; + } + + if (thisRangePredicate == null) + { + thisRangePredicate = c => true; + } - if (thisRangePredicate == null) thisRangePredicate = c => true; - if (otherRangePredicate == null) otherRangePredicate = c => true; + if (otherRangePredicate == null) + { + otherRangePredicate = c => true; + } - this.Cells(c => thisRangePredicate(c) && !otherRange.Cells(otherRangePredicate).Contains(c)).ForEach(c => cells.Add(c as XLCell)); + Cells(c => thisRangePredicate(c) && !otherRange.Cells(otherRangePredicate).Contains(c)).ForEach(c => cells.Add(c as XLCell)); return cells; } @@ -2242,7 +2527,9 @@ private IEnumerable CellsUsedInternal(XLCellsUsedOptions options, Func< // If opt == 0 then we're basically back at unconstrained, so just set back the original options if (opt == XLCellsUsedOptions.NoConstraints) + { opt = options; + } IEnumerable cellsUsed = CellsUsed(opt, predicate); @@ -2277,4 +2564,4 @@ private IEnumerable CellsUsedInternal(XLCellsUsedOptions options, Func< return cellsUsed; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Ranges/XLRangeColumn.cs b/ClosedXML/Excel/Ranges/XLRangeColumn.cs index 97ee3dd00..877b967ec 100644 --- a/ClosedXML/Excel/Ranges/XLRangeColumn.cs +++ b/ClosedXML/Excel/Ranges/XLRangeColumn.cs @@ -1,3 +1,5 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Tables; using System; using System.Linq; @@ -28,8 +30,11 @@ public override IXLCells Cells(string cellsInColumn) { var retVal = new XLCells(false, XLCellsUsedOptions.AllContents); var rangePairs = cellsInColumn.Split(','); - foreach (string pair in rangePairs) + foreach (var pair in rangePairs) + { retVal.Add(Range(pair.Trim()).RangeAddress); + } + return retVal; } @@ -43,14 +48,16 @@ public void Delete() Delete(true); } - internal void Delete(Boolean deleteTableField) + internal void Delete(bool deleteTableField) { if (deleteTableField && IsTableColumn()) { var table = Table as XLTable; var firstCellValue = Cell(1).Value.ToString(); if (!table.FieldNames.ContainsKey(firstCellValue)) + { throw new ArgumentException(string.Format("Field {0} not found.", firstCellValue)); + } var field = table.Fields.Cast().Single(f => f.Name == firstCellValue); field.Delete(false); @@ -84,9 +91,9 @@ public int CellCount() return RangeAddress.LastAddress.RowNumber - RangeAddress.FirstAddress.RowNumber + 1; } - public IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { - base.Sort(1, sortOrder, matchCase, ignoreBlanks); + Sort(1, sortOrder, matchCase, ignoreBlanks); return this; } @@ -94,12 +101,17 @@ public IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolea { base.CopyTo(target); - int lastRowNumber = target.Address.RowNumber + RowCount() - 1; + var lastRowNumber = target.Address.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - int lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range( target.Address.RowNumber, @@ -113,12 +125,17 @@ public IXLRangeColumn Sort(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolea { base.CopyTo(target); - int lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; + var lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - int lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.RangeAddress.FirstAddress.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range( target.RangeAddress.FirstAddress.RowNumber, @@ -142,7 +159,7 @@ public IXLRangeColumns Columns(string columns) { var retVal = new XLRangeColumns(); var rowPairs = columns.Split(','); - foreach (string trimmedPair in rowPairs.Select(pair => pair.Trim())) + foreach (var trimmedPair in rowPairs.Select(pair => pair.Trim())) { string firstRow; string lastRow; @@ -178,10 +195,7 @@ public IXLColumn WorksheetColumn() #endregion IXLRangeColumn Members - public override XLRangeType RangeType - { - get { return XLRangeType.RangeColumn; } - } + public override XLRangeType RangeType => XLRangeType.RangeColumn; public XLCell Cell(int row) { @@ -209,15 +223,19 @@ public override XLRange Range(string rangeAddressStr) if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-')) { if (rangeAddressStr.Contains('-')) + { rangeAddressStr = rangeAddressStr.Replace('-', ':'); + } var arrRange = rangeAddressStr.Split(':'); - string firstPart = arrRange[0]; - string secondPart = arrRange[1]; + var firstPart = arrRange[0]; + var secondPart = arrRange[1]; rangeAddressToUse = FixColumnAddress(firstPart) + ":" + FixColumnAddress(secondPart); } else + { rangeAddressToUse = FixColumnAddress(rangeAddressStr); + } var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse); return Range(rangeAddress); @@ -225,23 +243,29 @@ public override XLRange Range(string rangeAddressStr) public int CompareTo(XLRangeColumn otherColumn, IXLSortElements rowsToSort) { - foreach (IXLSortElement e in rowsToSort) + foreach (var e in rowsToSort) { var thisCell = Cell(e.ElementNumber); var otherCell = otherColumn.Cell(e.ElementNumber); int comparison; - bool thisCellIsBlank = thisCell.IsEmpty(); - bool otherCellIsBlank = otherCell.IsEmpty(); + var thisCellIsBlank = thisCell.IsEmpty(); + var otherCellIsBlank = otherCell.IsEmpty(); if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank)) { if (thisCellIsBlank && otherCellIsBlank) + { comparison = 0; + } else { if (thisCellIsBlank) + { comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1; + } else + { comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1; + } } } else @@ -252,29 +276,39 @@ public int CompareTo(XLRangeColumn otherColumn, IXLSortElements rowsToSort) { comparison = e.MatchCase ? thisCell.InnerText.CompareTo(otherCell.InnerText) - : String.Compare(thisCell.InnerText, otherCell.InnerText, true); + : string.Compare(thisCell.InnerText, otherCell.InnerText, true); } else if (thisCell.DataType == XLDataType.TimeSpan) + { comparison = thisCell.GetTimeSpan().CompareTo(otherCell.GetTimeSpan()); + } else - comparison = Double.Parse(thisCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture).CompareTo(Double.Parse(otherCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture)); + { + comparison = double.Parse(thisCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture).CompareTo(double.Parse(otherCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture)); + } } else if (e.MatchCase) - comparison = String.Compare(thisCell.GetString(), otherCell.GetString(), true); + { + comparison = string.Compare(thisCell.GetString(), otherCell.GetString(), true); + } else + { comparison = thisCell.GetString().CompareTo(otherCell.GetString()); + } } if (comparison != 0) + { return e.SortOrder == XLSortOrder.Ascending ? comparison : comparison * -1; + } } return 0; } - private XLRangeColumn ColumnShift(Int32 columnsToShift) + private XLRangeColumn ColumnShift(int columnsToShift) { - Int32 columnNumber = ColumnNumber() + columnsToShift; + var columnNumber = ColumnNumber() + columnsToShift; return Worksheet.Range( RangeAddress.FirstAddress.RowNumber, columnNumber, @@ -289,7 +323,7 @@ IXLRangeColumn IXLRangeColumn.ColumnLeft() return ColumnLeft(); } - IXLRangeColumn IXLRangeColumn.ColumnLeft(Int32 step) + IXLRangeColumn IXLRangeColumn.ColumnLeft(int step) { return ColumnLeft(step); } @@ -299,7 +333,7 @@ public XLRangeColumn ColumnLeft() return ColumnLeft(1); } - public XLRangeColumn ColumnLeft(Int32 step) + public XLRangeColumn ColumnLeft(int step) { return ColumnShift(step * -1); } @@ -313,7 +347,7 @@ IXLRangeColumn IXLRangeColumn.ColumnRight() return ColumnRight(); } - IXLRangeColumn IXLRangeColumn.ColumnRight(Int32 step) + IXLRangeColumn IXLRangeColumn.ColumnRight(int step) { return ColumnRight(step); } @@ -323,7 +357,7 @@ public XLRangeColumn ColumnRight() return ColumnRight(1); } - public XLRangeColumn ColumnRight(Int32 step) + public XLRangeColumn ColumnRight(int step) { return ColumnShift(step); } @@ -333,7 +367,9 @@ public XLRangeColumn ColumnRight(Int32 step) public IXLTable AsTable() { if (IsTableColumn()) + { throw new InvalidOperationException("This column is already part of a table."); + } return AsRange().AsTable(); } @@ -341,7 +377,9 @@ public IXLTable AsTable() public IXLTable AsTable(string name) { if (IsTableColumn()) + { throw new InvalidOperationException("This column is already part of a table."); + } return AsRange().AsTable(name); } @@ -349,7 +387,9 @@ public IXLTable AsTable(string name) public IXLTable CreateTable() { if (IsTableColumn()) + { throw new InvalidOperationException("This column is already part of a table."); + } return AsRange().CreateTable(); } @@ -357,7 +397,9 @@ public IXLTable CreateTable() public IXLTable CreateTable(string name) { if (IsTableColumn()) + { throw new InvalidOperationException("This column is already part of a table."); + } return AsRange().CreateTable(name); } @@ -369,7 +411,7 @@ public IXLTable CreateTable(string name) } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLRangeColumn ColumnUsed(Boolean includeFormats) + public IXLRangeColumn ColumnUsed(bool includeFormats) { return ColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -384,7 +426,7 @@ public IXLRangeColumn ColumnUsed(XLCellsUsedOptions options = XLCellsUsedOptions internal IXLTable Table { get; set; } - public Boolean IsTableColumn() + public bool IsTableColumn() { return Table != null; } diff --git a/ClosedXML/Excel/Ranges/XLRangeColumns.cs b/ClosedXML/Excel/Ranges/XLRangeColumns.cs index cedf4a188..be7ff1bf5 100644 --- a/ClosedXML/Excel/Ranges/XLRangeColumns.cs +++ b/ClosedXML/Excel/Ranges/XLRangeColumns.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; +using ClosedXML.Excel.Style; namespace ClosedXML.Excel { - using System.Collections; - internal class XLRangeColumns : XLStylizedBase, IXLRangeColumns, IXLStylized { private readonly List _ranges = new List(); @@ -49,21 +49,27 @@ IEnumerator IEnumerable.GetEnumerator() public IXLCells Cells() { var cells = new XLCells(usedCellsOnly: false, options: XLCellsUsedOptions.AllContents); - foreach (XLRangeColumn container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(usedCellsOnly: true, options: XLCellsUsedOptions.AllContents); - foreach (XLRangeColumn container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -74,8 +80,11 @@ public IXLCells CellsUsed(Boolean includeFormats) public IXLCells CellsUsed(XLCellsUsedOptions options) { var cells = new XLCells(usedCellsOnly: true, options: options); - foreach (XLRangeColumn container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } @@ -94,15 +103,17 @@ public override IEnumerable Styles get { yield return Style; - foreach (XLRangeColumn rng in _ranges) + foreach (var rng in _ranges) { yield return rng.Style; - foreach (XLCell r in rng.Worksheet.Internals.CellsCollection.GetCells( + foreach (var r in rng.Worksheet.Internals.CellsCollection.GetCells( rng.RangeAddress.FirstAddress.RowNumber, rng.RangeAddress.FirstAddress.ColumnNumber, rng.RangeAddress.LastAddress.RowNumber, rng.RangeAddress.LastAddress.ColumnNumber)) + { yield return r.Style; + } } } } @@ -112,7 +123,9 @@ protected override IEnumerable Children get { foreach (var range in _ranges) + { yield return range; + } } } @@ -131,7 +144,9 @@ public override IXLRanges RangesUsed public void Select() { foreach (var range in this) + { range.Select(); + } } } } diff --git a/ClosedXML/Excel/Ranges/XLRangeConsolidationEngine.cs b/ClosedXML/Excel/Ranges/XLRangeConsolidationEngine.cs index 8eb04a057..64ccf8420 100644 --- a/ClosedXML/Excel/Ranges/XLRangeConsolidationEngine.cs +++ b/ClosedXML/Excel/Ranges/XLRangeConsolidationEngine.cs @@ -15,7 +15,10 @@ internal class XLRangeConsolidationEngine public XLRangeConsolidationEngine(IXLRanges ranges) { if (ranges == null) + { throw new ArgumentNullException(nameof(ranges)); + } + _allRanges = ranges; } @@ -26,7 +29,9 @@ public XLRangeConsolidationEngine(IXLRanges ranges) public IXLRanges Consolidate() { if (!_allRanges.Any()) + { return _allRanges; + } var worksheets = _allRanges.Select(r => r.Worksheet).Distinct().OrderBy(ws => ws.Position); @@ -84,15 +89,18 @@ public XLRangeConsolidationMatrix(IXLWorksheet worksheet, IEnumerable public IEnumerable GetConsolidatedRanges() { var rowNumbers = _bitMatrix.Keys.OrderBy(k => k).ToArray(); - for (int i = 0; i < rowNumbers.Length; i++) + for (var i = 0; i < rowNumbers.Length; i++) { var startRow = rowNumbers[i]; var startings = GetRangesBoundariesStartingByRow(_bitMatrix[startRow]); foreach (var starting in startings) { - int j = i + 1; - while (j < rowNumbers.Length && RowIncludesRange(_bitMatrix[rowNumbers[j]], starting)) j++; + var j = i + 1; + while (j < rowNumbers.Length && RowIncludesRange(_bitMatrix[rowNumbers[j]], starting)) + { + j++; + } var endRow = rowNumbers[j - 1]; var startColumn = starting.Item1 + _minColumn - 1; @@ -115,7 +123,7 @@ public IEnumerable GetConsolidatedRanges() private readonly IXLWorksheet _worksheet; private Dictionary _bitMatrix; - private int _maxColumn = 0; + private int _maxColumn; private int _minColumn = XLHelper.MaxColumnNumber + 1; #endregion Private Fields @@ -133,7 +141,7 @@ private void AddToBitMatrix(IXLRangeAddress rangeAddress) foreach (var rowNum in rows) { - for (int i = minIndex; i <= maxIndex; i++) + for (var i = minIndex; i <= maxIndex; i++) { _bitMatrix[rowNum][i] = true; } @@ -142,7 +150,7 @@ private void AddToBitMatrix(IXLRangeAddress rangeAddress) private void ClearRangeInRow(BitArray rowArray, Tuple rangeBoundaries) { - for (int i = rangeBoundaries.Item1; i <= rangeBoundaries.Item2; i++) + for (var i = rangeBoundaries.Item1; i <= rangeBoundaries.Item2; i++) { rowArray[i] = false; } @@ -161,13 +169,18 @@ private void FillBitMatrix(IEnumerable ranges) private IEnumerable> GetRangesBoundariesStartingByRow(BitArray rowArray) { - int startIdx = 0; - for (int i = 1; i < rowArray.Length - 1; i++) + var startIdx = 0; + for (var i = 1; i < rowArray.Length - 1; i++) { if (!rowArray[i - 1] && rowArray[i]) + { startIdx = i; + } + if (rowArray[i] && !rowArray[i + 1]) + { yield return new Tuple(startIdx, i); + } } } @@ -185,11 +198,19 @@ private void PrepareBitMatrix(IEnumerable ranges) : address.LastAddress.ColumnNumber; if (!_bitMatrix.ContainsKey(address.FirstAddress.RowNumber)) + { _bitMatrix.Add(address.FirstAddress.RowNumber, null); + } + if (!_bitMatrix.ContainsKey(address.LastAddress.RowNumber)) + { _bitMatrix.Add(address.LastAddress.RowNumber, null); + } + if (!_bitMatrix.ContainsKey(address.LastAddress.RowNumber + 1)) + { _bitMatrix.Add(address.LastAddress.RowNumber + 1, null); + } } var keys = _bitMatrix.Keys.ToList(); @@ -200,10 +221,12 @@ private void PrepareBitMatrix(IEnumerable ranges) } private bool RowIncludesRange(BitArray rowArray, Tuple rangeBoundaries) { - for (int i = rangeBoundaries.Item1; i <= rangeBoundaries.Item2; i++) + for (var i = rangeBoundaries.Item1; i <= rangeBoundaries.Item2; i++) { if (!rowArray[i]) + { return false; + } } return true; diff --git a/ClosedXML/Excel/Ranges/XLRangeFactory.cs b/ClosedXML/Excel/Ranges/XLRangeFactory.cs index b3ded6499..384b00136 100644 --- a/ClosedXML/Excel/Ranges/XLRangeFactory.cs +++ b/ClosedXML/Excel/Ranges/XLRangeFactory.cs @@ -1,4 +1,6 @@ -using System; +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Tables; +using System; namespace ClosedXML.Excel { @@ -15,7 +17,10 @@ internal class XLRangeFactory public XLRangeFactory(XLWorksheet worksheet) { if (worksheet == null) + { throw new ArgumentNullException(nameof(worksheet)); + } + Worksheet = worksheet; } diff --git a/ClosedXML/Excel/Ranges/XLRangeKey.cs b/ClosedXML/Excel/Ranges/XLRangeKey.cs index 8fb4842a5..773e6020a 100644 --- a/ClosedXML/Excel/Ranges/XLRangeKey.cs +++ b/ClosedXML/Excel/Ranges/XLRangeKey.cs @@ -31,7 +31,11 @@ public bool Equals(XLRangeKey other) /// Another object to compare to. public override bool Equals(object obj) { - if (ReferenceEquals(null, obj)) return false; + if (obj is null) + { + return false; + } + return obj is XLRangeKey && Equals((XLRangeKey)obj); } diff --git a/ClosedXML/Excel/Ranges/XLRangeRow.cs b/ClosedXML/Excel/Ranges/XLRangeRow.cs index f8d0de9c7..6281488df 100644 --- a/ClosedXML/Excel/Ranges/XLRangeRow.cs +++ b/ClosedXML/Excel/Ranges/XLRangeRow.cs @@ -1,8 +1,9 @@ +using ClosedXML.Excel.Ranges; +using System; +using System.Linq; + namespace ClosedXML.Excel { - using System; - using System.Linq; - internal class XLRangeRow : XLRangeBase, IXLRangeRow { #region Constructor @@ -63,8 +64,11 @@ public override IXLCells Cells(string cellsInRow) { var retVal = new XLCells(false, XLCellsUsedOptions.AllContents); var rangePairs = cellsInRow.Split(','); - foreach (string pair in rangePairs) + foreach (var pair in rangePairs) + { retVal.Add(Range(pair.Trim()).RangeAddress); + } + return retVal; } @@ -89,7 +93,7 @@ public int CellCount() return SortLeftToRight(); } - public new IXLRangeRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRangeRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { base.SortLeftToRight(sortOrder, matchCase, ignoreBlanks); return this; @@ -99,12 +103,17 @@ public int CellCount() { base.CopyTo(target); - int lastRowNumber = target.Address.RowNumber + RowCount() - 1; + var lastRowNumber = target.Address.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - int lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.Address.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range( target.Address.RowNumber, @@ -117,12 +126,17 @@ public int CellCount() public new IXLRangeRow CopyTo(IXLRangeBase target) { base.CopyTo(target); - int lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; + var lastRowNumber = target.RangeAddress.FirstAddress.RowNumber + RowCount() - 1; if (lastRowNumber > XLHelper.MaxRowNumber) + { lastRowNumber = XLHelper.MaxRowNumber; - int lastColumnNumber = target.RangeAddress.LastAddress.ColumnNumber + ColumnCount() - 1; + } + + var lastColumnNumber = target.RangeAddress.LastAddress.ColumnNumber + ColumnCount() - 1; if (lastColumnNumber > XLHelper.MaxColumnNumber) + { lastColumnNumber = XLHelper.MaxColumnNumber; + } return target.Worksheet.Range( target.RangeAddress.FirstAddress.RowNumber, @@ -146,7 +160,7 @@ public IXLRangeRows Rows(string rows) { var retVal = new XLRangeRows(); var columnPairs = rows.Split(','); - foreach (string trimmedPair in columnPairs.Select(pair => pair.Trim())) + foreach (var trimmedPair in columnPairs.Select(pair => pair.Trim())) { string firstColumn; string lastColumn; @@ -182,10 +196,7 @@ public IXLRow WorksheetRow() } #endregion IXLRangeRow Members - public override XLRangeType RangeType - { - get { return XLRangeType.RangeRow; } - } + public override XLRangeType RangeType => XLRangeType.RangeRow; internal override void WorksheetRangeShiftedColumns(XLRange range, int columnsShifted) { @@ -208,15 +219,19 @@ public override XLRange Range(string rangeAddressStr) if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-')) { if (rangeAddressStr.Contains('-')) + { rangeAddressStr = rangeAddressStr.Replace('-', ':'); + } var arrRange = rangeAddressStr.Split(':'); - string firstPart = arrRange[0]; - string secondPart = arrRange[1]; + var firstPart = arrRange[0]; + var secondPart = arrRange[1]; rangeAddressToUse = FixRowAddress(firstPart) + ":" + FixRowAddress(secondPart); } else + { rangeAddressToUse = FixRowAddress(rangeAddressStr); + } var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse); return Range(rangeAddress); @@ -224,23 +239,29 @@ public override XLRange Range(string rangeAddressStr) public int CompareTo(XLRangeRow otherRow, IXLSortElements columnsToSort) { - foreach (IXLSortElement e in columnsToSort) + foreach (var e in columnsToSort) { var thisCell = (XLCell)Cell(e.ElementNumber); var otherCell = (XLCell)otherRow.Cell(e.ElementNumber); int comparison; - bool thisCellIsBlank = thisCell.IsEmpty(); - bool otherCellIsBlank = otherCell.IsEmpty(); + var thisCellIsBlank = thisCell.IsEmpty(); + var otherCellIsBlank = otherCell.IsEmpty(); if (e.IgnoreBlanks && (thisCellIsBlank || otherCellIsBlank)) { if (thisCellIsBlank && otherCellIsBlank) + { comparison = 0; + } else { if (thisCellIsBlank) + { comparison = e.SortOrder == XLSortOrder.Ascending ? 1 : -1; + } else + { comparison = e.SortOrder == XLSortOrder.Ascending ? -1 : 1; + } } } else @@ -252,7 +273,7 @@ public int CompareTo(XLRangeRow otherRow, IXLSortElements columnsToSort) case XLDataType.Text: comparison = e.MatchCase ? thisCell.InnerText.CompareTo(otherCell.InnerText) - : String.Compare(thisCell.InnerText, otherCell.InnerText, true); + : string.Compare(thisCell.InnerText, otherCell.InnerText, true); break; case XLDataType.TimeSpan: @@ -276,21 +297,27 @@ public int CompareTo(XLRangeRow otherRow, IXLSortElements columnsToSort) } } else if (e.MatchCase) - comparison = String.Compare(thisCell.GetString(), otherCell.GetString(), true); + { + comparison = string.Compare(thisCell.GetString(), otherCell.GetString(), true); + } else + { comparison = thisCell.GetString().CompareTo(otherCell.GetString()); + } } if (comparison != 0) + { return e.SortOrder == XLSortOrder.Ascending ? comparison : -comparison; + } } return 0; } - private XLRangeRow RowShift(Int32 rowsToShift) + private XLRangeRow RowShift(int rowsToShift) { - Int32 rowNum = RowNumber() + rowsToShift; + var rowNum = RowNumber() + rowsToShift; var range = Worksheet.Range( rowNum, @@ -308,7 +335,7 @@ IXLRangeRow IXLRangeRow.RowAbove() return RowAbove(); } - IXLRangeRow IXLRangeRow.RowAbove(Int32 step) + IXLRangeRow IXLRangeRow.RowAbove(int step) { return RowAbove(step); } @@ -318,7 +345,7 @@ public XLRangeRow RowAbove() return RowAbove(1); } - public XLRangeRow RowAbove(Int32 step) + public XLRangeRow RowAbove(int step) { return RowShift(step * -1); } @@ -332,7 +359,7 @@ IXLRangeRow IXLRangeRow.RowBelow() return RowBelow(); } - IXLRangeRow IXLRangeRow.RowBelow(Int32 step) + IXLRangeRow IXLRangeRow.RowBelow(int step) { return RowBelow(step); } @@ -342,7 +369,7 @@ public XLRangeRow RowBelow() return RowBelow(1); } - public XLRangeRow RowBelow(Int32 step) + public XLRangeRow RowBelow(int step) { return RowShift(step); } @@ -356,7 +383,7 @@ public XLRangeRow RowBelow(Int32 step) } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLRangeRow RowUsed(Boolean includeFormats) + public IXLRangeRow RowUsed(bool includeFormats) { return RowUsed(includeFormats ? XLCellsUsedOptions.All diff --git a/ClosedXML/Excel/Ranges/XLRangeRows.cs b/ClosedXML/Excel/Ranges/XLRangeRows.cs index ba1e5edbc..fa7489dd6 100644 --- a/ClosedXML/Excel/Ranges/XLRangeRows.cs +++ b/ClosedXML/Excel/Ranges/XLRangeRows.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; +using ClosedXML.Excel.Style; namespace ClosedXML.Excel { - using System.Collections; - internal class XLRangeRows : XLStylizedBase, IXLRangeRows, IXLStylized { private readonly List _ranges = new List(); @@ -49,21 +49,27 @@ IEnumerator IEnumerable.GetEnumerator() public IXLCells Cells() { var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - foreach (XLRangeRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(true, XLCellsUsedOptions.AllContents); - foreach (XLRangeRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -73,8 +79,11 @@ public IXLCells CellsUsed(Boolean includeFormats) public IXLCells CellsUsed(XLCellsUsedOptions options) { var cells = new XLCells(true, options); - foreach (XLRangeRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } @@ -93,15 +102,17 @@ public override IEnumerable Styles get { yield return Style; - foreach (XLRangeRow rng in _ranges) + foreach (var rng in _ranges) { yield return rng.Style; - foreach (XLCell r in rng.Worksheet.Internals.CellsCollection.GetCells( + foreach (var r in rng.Worksheet.Internals.CellsCollection.GetCells( rng.RangeAddress.FirstAddress.RowNumber, rng.RangeAddress.FirstAddress.ColumnNumber, rng.RangeAddress.LastAddress.RowNumber, rng.RangeAddress.LastAddress.ColumnNumber)) + { yield return r.Style; + } } } } @@ -111,7 +122,9 @@ protected override IEnumerable Children get { foreach (var range in _ranges) + { yield return range; + } } } @@ -131,7 +144,9 @@ public override IXLRanges RangesUsed public void Select() { foreach (var range in this) + { range.Select(); + } } } } diff --git a/ClosedXML/Excel/Ranges/XLRanges.cs b/ClosedXML/Excel/Ranges/XLRanges.cs index 0da17d892..9b8a91222 100644 --- a/ClosedXML/Excel/Ranges/XLRanges.cs +++ b/ClosedXML/Excel/Ranges/XLRanges.cs @@ -2,11 +2,12 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; +using ClosedXML.Excel.Style; +using ClosedXML.Excel.Ranges; namespace ClosedXML.Excel { - using System.Collections; - internal class XLRanges : XLStylizedBase, IXLRanges, IXLStylized { /// @@ -14,11 +15,11 @@ internal class XLRanges : XLStylizedBase, IXLRanges, IXLStylized /// private readonly Dictionary> _indexes; private IEnumerable Ranges => _indexes.Values.SelectMany(index => index.GetAll()); - private bool _styleInitialized = false; + private bool _styleInitialized; private IXLRangeIndex GetRangeIndex(IXLWorksheet worksheet) { - if (!_indexes.TryGetValue(worksheet, out IXLRangeIndex rangeIndex)) + if (!_indexes.TryGetValue(worksheet, out var rangeIndex)) { rangeIndex = new XLRangeIndex(worksheet); _indexes.Add(worksheet, rangeIndex); @@ -43,14 +44,20 @@ public IXLRanges Clear(XLClearOptions clearOptions = XLClearOptions.All) public void Add(XLRange range) { if (GetRangeIndex(range.Worksheet).Add(range)) + { Count++; + } if (_styleInitialized) + { return; + } var worksheetStyle = range?.Worksheet?.Style; if (worksheetStyle == null) + { return; + } InnerStyle = worksheetStyle; _styleInitialized = true; @@ -109,12 +116,12 @@ IEnumerator IEnumerable.GetEnumerator() return GetEnumerator(); } - public Boolean Contains(IXLCell cell) + public bool Contains(IXLCell cell) { return GetIntersectedRanges((XLAddress)cell.Address).Any(); } - public Boolean Contains(IXLRange range) + public bool Contains(IXLRange range) { return GetIntersectedRanges((XLRangeAddress)range.RangeAddress) .Any(r => r.Contains(range)); @@ -157,28 +164,25 @@ public IEnumerable GetIntersectedRanges(IXLCell cell) return GetIntersectedRanges(cell.Address); } - public IEnumerable DataValidation - { - get { return Ranges.Select(range => range.GetDataValidation()).Where(dv => dv != null); } - } + public IEnumerable DataValidation => Ranges.Select(range => range.GetDataValidation()).Where(dv => dv != null); - public IXLRanges AddToNamed(String rangeName) + public IXLRanges AddToNamed(string rangeName) { return AddToNamed(rangeName, XLScope.Workbook); } - public IXLRanges AddToNamed(String rangeName, XLScope scope) + public IXLRanges AddToNamed(string rangeName, XLScope scope) { return AddToNamed(rangeName, XLScope.Workbook, null); } - public IXLRanges AddToNamed(String rangeName, XLScope scope, String comment) + public IXLRanges AddToNamed(string rangeName, XLScope scope, string comment) { Ranges.ForEach(r => r.AddToNamed(rangeName, scope, comment)); return this; } - public Object Value + public object Value { set { Ranges.ForEach(r => r.Value = value); } } @@ -192,21 +196,27 @@ public IXLRanges SetValue(T value) public IXLCells Cells() { var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - foreach (XLRange container in Ranges) + foreach (var container in Ranges) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(true, XLCellsUsedOptions.AllContents); - foreach (XLRange container in Ranges) + foreach (var container in Ranges) + { cells.Add(container.RangeAddress); + } + return cells; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -216,8 +226,11 @@ public IXLCells CellsUsed(Boolean includeFormats) public IXLCells CellsUsed(XLCellsUsedOptions options) { var cells = new XLCells(true, options); - foreach (XLRange container in Ranges) + foreach (var container in Ranges) + { cells.Add(container.RangeAddress); + } + return cells; } @@ -236,15 +249,17 @@ public override IEnumerable Styles get { yield return Style; - foreach (XLRange rng in Ranges) + foreach (var rng in Ranges) { yield return rng.Style; - foreach (XLCell r in rng.Worksheet.Internals.CellsCollection.GetCells( + foreach (var r in rng.Worksheet.Internals.CellsCollection.GetCells( rng.RangeAddress.FirstAddress.RowNumber, rng.RangeAddress.FirstAddress.ColumnNumber, rng.RangeAddress.LastAddress.RowNumber, rng.RangeAddress.LastAddress.ColumnNumber)) + { yield return r.Style; + } } } } @@ -253,22 +268,25 @@ protected override IEnumerable Children { get { - foreach (XLRange rng in Ranges) + foreach (var rng in Ranges) + { yield return rng; + } } } - public override IXLRanges RangesUsed - { - get { return this; } - } + public override IXLRanges RangesUsed => this; #endregion IXLStylized Members public override string ToString() { - String retVal = Ranges.Aggregate(String.Empty, (agg, r) => agg + (r.ToString() + ",")); - if (retVal.Length > 0) retVal = retVal.Substring(0, retVal.Length - 1); + var retVal = Ranges.Aggregate(string.Empty, (agg, r) => agg + r.ToString() + ","); + if (retVal.Length > 0) + { + retVal = retVal.Substring(0, retVal.Length - 1); + } + return retVal; } @@ -280,7 +298,9 @@ public override bool Equals(object obj) public bool Equals(XLRanges other) { if (other == null) + { return false; + } return Ranges.Count() == other.Ranges.Count() && Ranges.Select(thisRange => Enumerable.Contains(other.Ranges, thisRange)).All(foundOne => foundOne); @@ -313,7 +333,9 @@ public IXLDataValidation SetDataValidation() public void Select() { foreach (var range in this) + { range.Select(); + } } public IXLRanges Consolidate() diff --git a/ClosedXML/Excel/RichText/IXLFormattedText.cs b/ClosedXML/Excel/RichText/IXLFormattedText.cs index 3180bee97..e92837566 100644 --- a/ClosedXML/Excel/RichText/IXLFormattedText.cs +++ b/ClosedXML/Excel/RichText/IXLFormattedText.cs @@ -5,38 +5,38 @@ namespace ClosedXML.Excel { public interface IXLFormattedText : IEnumerable, IEquatable>, IXLWithRichString { - Boolean Bold { set; } - Boolean Italic { set; } + bool Bold { set; } + bool Italic { set; } XLFontUnderlineValues Underline { set; } - Boolean Strikethrough { set; } + bool Strikethrough { set; } XLFontVerticalTextAlignmentValues VerticalAlignment { set; } - Boolean Shadow { set; } - Double FontSize { set; } + bool Shadow { set; } + double FontSize { set; } XLColor FontColor { set; } - String FontName { set; } + string FontName { set; } XLFontFamilyNumberingValues FontFamilyNumbering { set; } - IXLFormattedText SetBold(); IXLFormattedText SetBold(Boolean value); - IXLFormattedText SetItalic(); IXLFormattedText SetItalic(Boolean value); + IXLFormattedText SetBold(); IXLFormattedText SetBold(bool value); + IXLFormattedText SetItalic(); IXLFormattedText SetItalic(bool value); IXLFormattedText SetUnderline(); IXLFormattedText SetUnderline(XLFontUnderlineValues value); - IXLFormattedText SetStrikethrough(); IXLFormattedText SetStrikethrough(Boolean value); + IXLFormattedText SetStrikethrough(); IXLFormattedText SetStrikethrough(bool value); IXLFormattedText SetVerticalAlignment(XLFontVerticalTextAlignmentValues value); - IXLFormattedText SetShadow(); IXLFormattedText SetShadow(Boolean value); - IXLFormattedText SetFontSize(Double value); + IXLFormattedText SetShadow(); IXLFormattedText SetShadow(bool value); + IXLFormattedText SetFontSize(double value); IXLFormattedText SetFontColor(XLColor value); - IXLFormattedText SetFontName(String value); + IXLFormattedText SetFontName(string value); IXLFormattedText SetFontFamilyNumbering(XLFontFamilyNumberingValues value); - IXLRichString AddText(String text, IXLFontBase font); + IXLRichString AddText(string text, IXLFontBase font); IXLFormattedText ClearText(); IXLFormattedText ClearFont(); - IXLFormattedText Substring(Int32 index); - IXLFormattedText Substring(Int32 index, Int32 length); - Int32 Count { get; } - Int32 Length { get; } + IXLFormattedText Substring(int index); + IXLFormattedText Substring(int index, int length); + int Count { get; } + int Length { get; } - String Text { get; } + string Text { get; } IXLPhonetics Phonetics { get; } - Boolean HasPhonetics { get; } + bool HasPhonetics { get; } } } diff --git a/ClosedXML/Excel/RichText/IXLPhonetic.cs b/ClosedXML/Excel/RichText/IXLPhonetic.cs index 56e20f9d0..ef18c7d84 100644 --- a/ClosedXML/Excel/RichText/IXLPhonetic.cs +++ b/ClosedXML/Excel/RichText/IXLPhonetic.cs @@ -4,8 +4,8 @@ namespace ClosedXML.Excel { public interface IXLPhonetic: IEquatable { - String Text { get; set; } - Int32 Start { get; set; } - Int32 End { get; set; } + string Text { get; set; } + int Start { get; set; } + int End { get; set; } } } diff --git a/ClosedXML/Excel/RichText/IXLPhonetics.cs b/ClosedXML/Excel/RichText/IXLPhonetics.cs index 67cd96de3..089760554 100644 --- a/ClosedXML/Excel/RichText/IXLPhonetics.cs +++ b/ClosedXML/Excel/RichText/IXLPhonetics.cs @@ -7,22 +7,22 @@ public enum XLPhoneticAlignment { Center, Distributed, Left, NoControl } public enum XLPhoneticType { FullWidthKatakana, HalfWidthKatakana, Hiragana, NoConversion } public interface IXLPhonetics : IXLFontBase, IEnumerable, IEquatable { - IXLPhonetics SetBold(); IXLPhonetics SetBold(Boolean value); - IXLPhonetics SetItalic(); IXLPhonetics SetItalic(Boolean value); + IXLPhonetics SetBold(); IXLPhonetics SetBold(bool value); + IXLPhonetics SetItalic(); IXLPhonetics SetItalic(bool value); IXLPhonetics SetUnderline(); IXLPhonetics SetUnderline(XLFontUnderlineValues value); - IXLPhonetics SetStrikethrough(); IXLPhonetics SetStrikethrough(Boolean value); + IXLPhonetics SetStrikethrough(); IXLPhonetics SetStrikethrough(bool value); IXLPhonetics SetVerticalAlignment(XLFontVerticalTextAlignmentValues value); - IXLPhonetics SetShadow(); IXLPhonetics SetShadow(Boolean value); - IXLPhonetics SetFontSize(Double value); + IXLPhonetics SetShadow(); IXLPhonetics SetShadow(bool value); + IXLPhonetics SetFontSize(double value); IXLPhonetics SetFontColor(XLColor value); - IXLPhonetics SetFontName(String value); + IXLPhonetics SetFontName(string value); IXLPhonetics SetFontFamilyNumbering(XLFontFamilyNumberingValues value); IXLPhonetics SetFontCharSet(XLFontCharSet value); - IXLPhonetics Add(String text, Int32 start, Int32 end); + IXLPhonetics Add(string text, int start, int end); IXLPhonetics ClearText(); IXLPhonetics ClearFont(); - Int32 Count { get; } + int Count { get; } XLPhoneticAlignment Alignment { get; set; } XLPhoneticType Type { get; set; } diff --git a/ClosedXML/Excel/RichText/IXLRichString.cs b/ClosedXML/Excel/RichText/IXLRichString.cs index a0904603e..bcd4d9c5a 100644 --- a/ClosedXML/Excel/RichText/IXLRichString.cs +++ b/ClosedXML/Excel/RichText/IXLRichString.cs @@ -4,23 +4,23 @@ namespace ClosedXML.Excel { public interface IXLWithRichString { - IXLRichString AddText(String text); + IXLRichString AddText(string text); IXLRichString AddNewLine(); } public interface IXLRichString: IXLFontBase, IEquatable, IXLWithRichString { - String Text { get; set; } + string Text { get; set; } - IXLRichString SetBold(); IXLRichString SetBold(Boolean value); - IXLRichString SetItalic(); IXLRichString SetItalic(Boolean value); + IXLRichString SetBold(); IXLRichString SetBold(bool value); + IXLRichString SetItalic(); IXLRichString SetItalic(bool value); IXLRichString SetUnderline(); IXLRichString SetUnderline(XLFontUnderlineValues value); - IXLRichString SetStrikethrough(); IXLRichString SetStrikethrough(Boolean value); + IXLRichString SetStrikethrough(); IXLRichString SetStrikethrough(bool value); IXLRichString SetVerticalAlignment(XLFontVerticalTextAlignmentValues value); - IXLRichString SetShadow(); IXLRichString SetShadow(Boolean value); - IXLRichString SetFontSize(Double value); + IXLRichString SetShadow(); IXLRichString SetShadow(bool value); + IXLRichString SetFontSize(double value); IXLRichString SetFontColor(XLColor value); - IXLRichString SetFontName(String value); + IXLRichString SetFontName(string value); IXLRichString SetFontFamilyNumbering(XLFontFamilyNumberingValues value); IXLRichString SetFontCharSet(XLFontCharSet value); } diff --git a/ClosedXML/Excel/RichText/IXLRichText.cs b/ClosedXML/Excel/RichText/IXLRichText.cs index 46efd4197..f1fbaede6 100644 --- a/ClosedXML/Excel/RichText/IXLRichText.cs +++ b/ClosedXML/Excel/RichText/IXLRichText.cs @@ -1,6 +1,3 @@ -using System; -using System.Collections.Generic; - namespace ClosedXML.Excel { public interface IXLRichText : IXLFormattedText diff --git a/ClosedXML/Excel/RichText/XLFormattedText.cs b/ClosedXML/Excel/RichText/XLFormattedText.cs index 37484780d..f48108305 100644 --- a/ClosedXML/Excel/RichText/XLFormattedText.cs +++ b/ClosedXML/Excel/RichText/XLFormattedText.cs @@ -1,16 +1,17 @@ using System; using System.Collections.Generic; -using System.Text; using System.Linq; +using System.Text; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.RichText { - internal class XLFormattedText: IXLFormattedText + internal class XLFormattedText : IXLFormattedText { - List _richTexts = new List(); + private List _richTexts = new List(); protected T Container; - readonly IXLFontBase _defaultFont; + private readonly IXLFontBase _defaultFont; + public XLFormattedText(IXLFontBase defaultFont) { Length = 0; @@ -21,27 +22,32 @@ public XLFormattedText(IXLFormattedText defaultRichText, IXLFontBase defaultF : this(defaultFont) { foreach (var rt in defaultRichText) + { AddText(rt.Text, rt); + } + if (defaultRichText.HasPhonetics) { _phonetics = new XLPhonetics(defaultRichText.Phonetics, defaultFont); } } - public XLFormattedText(String text, IXLFontBase defaultFont) - :this(defaultFont) + public XLFormattedText(string text, IXLFontBase defaultFont) + : this(defaultFont) { AddText(text); } - public Int32 Count { get { return _richTexts.Count; } } + public int Count => _richTexts.Count; + public int Length { get; private set; } - public IXLRichString AddText(String text) + public IXLRichString AddText(string text) { return AddText(text, _defaultFont); } - public IXLRichString AddText(String text, IXLFontBase font) + + public IXLRichString AddText(string text, IXLFontBase font) { var richText = new XLRichString(text, font, this); return AddText(richText); @@ -56,7 +62,7 @@ public IXLRichString AddText(IXLRichString richText) public IXLRichString AddNewLine() { - return AddText(Environment.NewLine); + return AddText(XLConstants.NewLine); } public IXLFormattedText ClearText() @@ -65,9 +71,10 @@ public IXLFormattedText ClearText() Length = 0; return this; } + public IXLFormattedText ClearFont() { - String text = Text; + var text = Text; ClearText(); AddText(text); return this; @@ -80,19 +87,22 @@ public override string ToString() return sb.ToString(); } - public IXLFormattedText Substring(Int32 index) + public IXLFormattedText Substring(int index) { return Substring(index, Length - index); } - public IXLFormattedText Substring(Int32 index, Int32 length) + + public IXLFormattedText Substring(int index, int length) { - if (index + 1 > Length || (Length - index + 1) < length || length <= 0) + if (index + 1 > Length || Length - index + 1 < length || length <= 0) + { throw new IndexOutOfRangeException("Index and length must refer to a location within the string."); + } - List newRichTexts = new List(); + var newRichTexts = new List(); var retVal = new XLFormattedText(_defaultFont); - Int32 lastPosition = 0; + var lastPosition = 0; foreach (var rt in _richTexts) { if (lastPosition >= index + 1 + length) // We already have what we need @@ -101,23 +111,31 @@ public IXLFormattedText Substring(Int32 index, Int32 length) } else if (lastPosition + rt.Text.Length >= index + 1) // Eureka! { - Int32 startIndex = index - lastPosition; + var startIndex = index - lastPosition; if (startIndex > 0) + { newRichTexts.Add(new XLRichString(rt.Text.Substring(0, startIndex), rt, this)); + } else if (startIndex < 0) + { startIndex = 0; + } - Int32 leftToTake = length - retVal.Length; + var leftToTake = length - retVal.Length; if (leftToTake > rt.Text.Length - startIndex) + { leftToTake = rt.Text.Length - startIndex; + } - XLRichString newRt = new XLRichString(rt.Text.Substring(startIndex, leftToTake), rt, this); + var newRt = new XLRichString(rt.Text.Substring(startIndex, leftToTake), rt, this); newRichTexts.Add(newRt); retVal.AddText(newRt); if (startIndex + leftToTake < rt.Text.Length) + { newRichTexts.Add(new XLRichString(rt.Text.Substring(startIndex + leftToTake), rt, this)); + } } else // We haven't reached the desired position yet { @@ -139,51 +157,106 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() return GetEnumerator(); } - public Boolean Bold { set { _richTexts.ForEach(rt => rt.Bold = value); } } - public Boolean Italic { set { _richTexts.ForEach(rt => rt.Italic = value); } } - public XLFontUnderlineValues Underline { set { _richTexts.ForEach(rt => rt.Underline = value); } } - public Boolean Strikethrough { set { _richTexts.ForEach(rt => rt.Strikethrough = value); } } - public XLFontVerticalTextAlignmentValues VerticalAlignment { set { _richTexts.ForEach(rt => rt.VerticalAlignment = value); } } - public Boolean Shadow { set { _richTexts.ForEach(rt => rt.Shadow = value); } } - public Double FontSize { set { _richTexts.ForEach(rt => rt.FontSize = value); } } - public XLColor FontColor { set { _richTexts.ForEach(rt => rt.FontColor = value); } } - public String FontName { set { _richTexts.ForEach(rt => rt.FontName = value); } } - public XLFontFamilyNumberingValues FontFamilyNumbering { set { _richTexts.ForEach(rt => rt.FontFamilyNumbering = value); } } - - public IXLFormattedText SetBold() { Bold = true; return this; } public IXLFormattedText SetBold(Boolean value) { Bold = value; return this; } - public IXLFormattedText SetItalic() { Italic = true; return this; } public IXLFormattedText SetItalic(Boolean value) { Italic = value; return this; } - public IXLFormattedText SetUnderline() { Underline = XLFontUnderlineValues.Single; return this; } public IXLFormattedText SetUnderline(XLFontUnderlineValues value) { Underline = value; return this; } - public IXLFormattedText SetStrikethrough() { Strikethrough = true; return this; } public IXLFormattedText SetStrikethrough(Boolean value) { Strikethrough = value; return this; } - public IXLFormattedText SetVerticalAlignment(XLFontVerticalTextAlignmentValues value) { VerticalAlignment = value; return this; } - public IXLFormattedText SetShadow() { Shadow = true; return this; } public IXLFormattedText SetShadow(Boolean value) { Shadow = value; return this; } - public IXLFormattedText SetFontSize(Double value) { FontSize = value; return this; } - public IXLFormattedText SetFontColor(XLColor value) { FontColor = value; return this; } - public IXLFormattedText SetFontName(String value) { FontName = value; return this; } - public IXLFormattedText SetFontFamilyNumbering(XLFontFamilyNumberingValues value) { FontFamilyNumbering = value; return this; } + public bool Bold + { set { _richTexts.ForEach(rt => rt.Bold = value); } } + + public bool Italic + { set { _richTexts.ForEach(rt => rt.Italic = value); } } + + public XLFontUnderlineValues Underline + { set { _richTexts.ForEach(rt => rt.Underline = value); } } + + public bool Strikethrough + { set { _richTexts.ForEach(rt => rt.Strikethrough = value); } } + + public XLFontVerticalTextAlignmentValues VerticalAlignment + { set { _richTexts.ForEach(rt => rt.VerticalAlignment = value); } } + + public bool Shadow + { set { _richTexts.ForEach(rt => rt.Shadow = value); } } + + public double FontSize + { set { _richTexts.ForEach(rt => rt.FontSize = value); } } + + public XLColor FontColor + { set { _richTexts.ForEach(rt => rt.FontColor = value); } } + + public string FontName + { set { _richTexts.ForEach(rt => rt.FontName = value); } } + + public XLFontFamilyNumberingValues FontFamilyNumbering + { set { _richTexts.ForEach(rt => rt.FontFamilyNumbering = value); } } + + public IXLFormattedText SetBold() + { Bold = true; return this; } + + public IXLFormattedText SetBold(bool value) + { Bold = value; return this; } + + public IXLFormattedText SetItalic() + { Italic = true; return this; } + + public IXLFormattedText SetItalic(bool value) + { Italic = value; return this; } + + public IXLFormattedText SetUnderline() + { Underline = XLFontUnderlineValues.Single; return this; } + + public IXLFormattedText SetUnderline(XLFontUnderlineValues value) + { Underline = value; return this; } + + public IXLFormattedText SetStrikethrough() + { Strikethrough = true; return this; } + + public IXLFormattedText SetStrikethrough(bool value) + { Strikethrough = value; return this; } + + public IXLFormattedText SetVerticalAlignment(XLFontVerticalTextAlignmentValues value) + { VerticalAlignment = value; return this; } + + public IXLFormattedText SetShadow() + { Shadow = true; return this; } + + public IXLFormattedText SetShadow(bool value) + { Shadow = value; return this; } + + public IXLFormattedText SetFontSize(double value) + { FontSize = value; return this; } + + public IXLFormattedText SetFontColor(XLColor value) + { FontColor = value; return this; } + + public IXLFormattedText SetFontName(string value) + { FontName = value; return this; } + + public IXLFormattedText SetFontFamilyNumbering(XLFontFamilyNumberingValues value) + { FontFamilyNumbering = value; return this; } public bool Equals(IXLFormattedText other) { - Int32 count = Count; + var count = Count; if (count != other.Count) + { return false; + } - for (Int32 i = 0; i < count; i++) + for (var i = 0; i < count; i++) { if (_richTexts.ElementAt(i) != other.ElementAt(i)) + { return false; + } } return _phonetics == null || Phonetics.Equals(other.Phonetics); } - public String Text { get { return ToString(); } } + public string Text => ToString(); private IXLPhonetics _phonetics; - public IXLPhonetics Phonetics - { - get { return _phonetics ?? (_phonetics = new XLPhonetics(_defaultFont)); } - } - public Boolean HasPhonetics { get { return _phonetics != null; } } + public IXLPhonetics Phonetics => _phonetics ??= new XLPhonetics(_defaultFont); + + public bool HasPhonetics => _phonetics != null; } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/RichText/XLPhonetic.cs b/ClosedXML/Excel/RichText/XLPhonetic.cs index 253a24fd1..29b6d267e 100644 --- a/ClosedXML/Excel/RichText/XLPhonetic.cs +++ b/ClosedXML/Excel/RichText/XLPhonetic.cs @@ -1,23 +1,23 @@ -using System; - namespace ClosedXML.Excel { internal class XLPhonetic: IXLPhonetic { - public XLPhonetic(String text, Int32 start, Int32 end) + public XLPhonetic(string text, int start, int end) { Text = text; Start = start; End = end; } - public String Text { get; set; } - public Int32 Start { get; set; } - public Int32 End { get; set; } + public string Text { get; set; } + public int Start { get; set; } + public int End { get; set; } public bool Equals(IXLPhonetic other) { if (other == null) + { return false; + } return Text == other.Text && Start == other.Start && End == other.End; } diff --git a/ClosedXML/Excel/RichText/XLPhonetics.cs b/ClosedXML/Excel/RichText/XLPhonetics.cs index b0482673c..6077d5e77 100644 --- a/ClosedXML/Excel/RichText/XLPhonetics.cs +++ b/ClosedXML/Excel/RichText/XLPhonetics.cs @@ -1,4 +1,4 @@ -using System; +using ClosedXML.Extensions; using System.Collections.Generic; using System.Linq; @@ -27,25 +27,25 @@ public XLPhonetics(IXLPhonetics defaultPhonetics, IXLFontBase defaultFont) this.CopyFont(defaultPhonetics); } - public Boolean Bold { get; set; } - public Boolean Italic { get; set; } + public bool Bold { get; set; } + public bool Italic { get; set; } public XLFontUnderlineValues Underline { get; set; } - public Boolean Strikethrough { get; set; } + public bool Strikethrough { get; set; } public XLFontVerticalTextAlignmentValues VerticalAlignment { get; set; } - public Boolean Shadow { get; set; } - public Double FontSize { get; set; } + public bool Shadow { get; set; } + public double FontSize { get; set; } public XLColor FontColor { get; set; } - public String FontName { get; set; } + public string FontName { get; set; } public XLFontFamilyNumberingValues FontFamilyNumbering { get; set; } public XLFontCharSet FontCharSet { get; set; } public IXLPhonetics SetBold() { Bold = true; return this; } - public IXLPhonetics SetBold(Boolean value) { Bold = value; return this; } + public IXLPhonetics SetBold(bool value) { Bold = value; return this; } public IXLPhonetics SetItalic() { Italic = true; return this; } - public IXLPhonetics SetItalic(Boolean value) { Italic = value; return this; } + public IXLPhonetics SetItalic(bool value) { Italic = value; return this; } public IXLPhonetics SetUnderline() { Underline = XLFontUnderlineValues.Single; return this; } @@ -53,25 +53,25 @@ public XLPhonetics(IXLPhonetics defaultPhonetics, IXLFontBase defaultFont) public IXLPhonetics SetStrikethrough() { Strikethrough = true; return this; } - public IXLPhonetics SetStrikethrough(Boolean value) { Strikethrough = value; return this; } + public IXLPhonetics SetStrikethrough(bool value) { Strikethrough = value; return this; } public IXLPhonetics SetVerticalAlignment(XLFontVerticalTextAlignmentValues value) { VerticalAlignment = value; return this; } public IXLPhonetics SetShadow() { Shadow = true; return this; } - public IXLPhonetics SetShadow(Boolean value) { Shadow = value; return this; } + public IXLPhonetics SetShadow(bool value) { Shadow = value; return this; } - public IXLPhonetics SetFontSize(Double value) { FontSize = value; return this; } + public IXLPhonetics SetFontSize(double value) { FontSize = value; return this; } public IXLPhonetics SetFontColor(XLColor value) { FontColor = value; return this; } - public IXLPhonetics SetFontName(String value) { FontName = value; return this; } + public IXLPhonetics SetFontName(string value) { FontName = value; return this; } public IXLPhonetics SetFontFamilyNumbering(XLFontFamilyNumberingValues value) { FontFamilyNumbering = value; return this; } public IXLPhonetics SetFontCharSet(XLFontCharSet value) { FontCharSet = value; return this; } - public IXLPhonetics Add(String text, Int32 start, Int32 end) + public IXLPhonetics Add(string text, int start, int end) { _phonetics.Add(new XLPhonetic(text, start, end)); return this; @@ -89,7 +89,7 @@ public IXLPhonetics ClearFont() return this; } - public Int32 Count { get { return _phonetics.Count; } } + public int Count => _phonetics.Count; public XLPhoneticAlignment Alignment { get; set; } public XLPhoneticType Type { get; set; } @@ -111,13 +111,17 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() public bool Equals(IXLPhonetics other) { if (other == null) + { return false; + } - Int32 phoneticsCount = _phonetics.Count; - for (Int32 i = 0; i < phoneticsCount; i++) + var phoneticsCount = _phonetics.Count; + for (var i = 0; i < phoneticsCount; i++) { if (!_phonetics[i].Equals(other.ElementAt(i))) + { return false; + } } return diff --git a/ClosedXML/Excel/RichText/XLRichString.cs b/ClosedXML/Excel/RichText/XLRichString.cs index 5a82aabb7..43f0dba06 100644 --- a/ClosedXML/Excel/RichText/XLRichString.cs +++ b/ClosedXML/Excel/RichText/XLRichString.cs @@ -1,41 +1,41 @@ -using System; +using ClosedXML.Extensions; using System.Diagnostics; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.RichText { [DebuggerDisplay("{Text}")] internal class XLRichString : IXLRichString { - private IXLWithRichString _withRichString; + private readonly IXLWithRichString _withRichString; - public XLRichString(String text, IXLFontBase font, IXLWithRichString withRichString) + public XLRichString(string text, IXLFontBase font, IXLWithRichString withRichString) { Text = text; this.CopyFont(font); _withRichString = withRichString; } - public String Text { get; set; } + public string Text { get; set; } - public IXLRichString AddText(String text) + public IXLRichString AddText(string text) { return _withRichString.AddText(text); } public IXLRichString AddNewLine() { - return AddText(Environment.NewLine); + return AddText(XLConstants.NewLine); } - public Boolean Bold { get; set; } - public Boolean Italic { get; set; } + public bool Bold { get; set; } + public bool Italic { get; set; } public XLFontUnderlineValues Underline { get; set; } - public Boolean Strikethrough { get; set; } + public bool Strikethrough { get; set; } public XLFontVerticalTextAlignmentValues VerticalAlignment { get; set; } - public Boolean Shadow { get; set; } - public Double FontSize { get; set; } + public bool Shadow { get; set; } + public double FontSize { get; set; } public XLColor FontColor { get; set; } - public String FontName { get; set; } + public string FontName { get; set; } public XLFontFamilyNumberingValues FontFamilyNumbering { get; set; } public XLFontCharSet FontCharSet { get; set; } @@ -44,7 +44,7 @@ public IXLRichString SetBold() Bold = true; return this; } - public IXLRichString SetBold(Boolean value) + public IXLRichString SetBold(bool value) { Bold = value; return this; } @@ -54,7 +54,7 @@ public IXLRichString SetItalic() Italic = true; return this; } - public IXLRichString SetItalic(Boolean value) + public IXLRichString SetItalic(bool value) { Italic = value; return this; } @@ -74,7 +74,7 @@ public IXLRichString SetStrikethrough() Strikethrough = true; return this; } - public IXLRichString SetStrikethrough(Boolean value) + public IXLRichString SetStrikethrough(bool value) { Strikethrough = value; return this; } @@ -89,12 +89,12 @@ public IXLRichString SetShadow() Shadow = true; return this; } - public IXLRichString SetShadow(Boolean value) + public IXLRichString SetShadow(bool value) { Shadow = value; return this; } - public IXLRichString SetFontSize(Double value) + public IXLRichString SetFontSize(double value) { FontSize = value; return this; } @@ -104,7 +104,7 @@ public IXLRichString SetFontColor(XLColor value) FontColor = value; return this; } - public IXLRichString SetFontName(String value) + public IXLRichString SetFontName(string value) { FontName = value; return this; } @@ -119,7 +119,7 @@ public IXLRichString SetFontCharSet(XLFontCharSet value) FontCharSet = value; return this; } - public Boolean Equals(IXLRichString other) + public bool Equals(IXLRichString other) { return Text == other.Text @@ -146,14 +146,14 @@ public override int GetHashCode() return Text.GetHashCode() ^ Bold.GetHashCode() ^ Italic.GetHashCode() - ^ (Int32)Underline + ^ (int)Underline ^ Strikethrough.GetHashCode() - ^ (Int32)VerticalAlignment + ^ (int)VerticalAlignment ^ Shadow.GetHashCode() ^ FontSize.GetHashCode() ^ FontColor.GetHashCode() ^ FontName.GetHashCode() - ^ (Int32)FontFamilyNumbering; + ^ (int)FontFamilyNumbering; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/RichText/XLRichText.cs b/ClosedXML/Excel/RichText/XLRichText.cs index aaad29a4b..6adbb9112 100644 --- a/ClosedXML/Excel/RichText/XLRichText.cs +++ b/ClosedXML/Excel/RichText/XLRichText.cs @@ -1,7 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Text; -using System.Linq; +using ClosedXML.Excel.RichText; namespace ClosedXML.Excel { @@ -20,7 +17,7 @@ public XLRichText(XLFormattedText defaultRichText, IXLFontBase defa Container = this; } - public XLRichText(String text, IXLFontBase defaultFont) + public XLRichText(string text, IXLFontBase defaultFont) :base(text, defaultFont) { Container = this; diff --git a/ClosedXML/Excel/Rows/IXLRow.cs b/ClosedXML/Excel/Rows/IXLRow.cs index 045ab5b2f..608bcc89b 100644 --- a/ClosedXML/Excel/Rows/IXLRow.cs +++ b/ClosedXML/Excel/Rows/IXLRow.cs @@ -10,7 +10,7 @@ public interface IXLRow : IXLRangeBase /// /// The width of this row. /// - Double Height { get; set; } + double Height { get; set; } /// /// Clears the height for the row and defaults it to the spreadsheet row height. @@ -25,21 +25,21 @@ public interface IXLRow : IXLRangeBase /// /// Gets this row's number /// - Int32 RowNumber(); + int RowNumber(); /// /// Inserts X number of rows below this one. /// All rows below will be shifted accordingly. /// /// The number of rows to insert. - IXLRows InsertRowsBelow(Int32 numberOfRows); + IXLRows InsertRowsBelow(int numberOfRows); /// /// Inserts X number of rows above this one. /// This row and all below will be shifted accordingly. /// /// The number of rows to insert. - IXLRows InsertRowsAbove(Int32 numberOfRows); + IXLRows InsertRowsAbove(int numberOfRows); IXLRow AdjustToContents(); @@ -47,20 +47,20 @@ public interface IXLRow : IXLRangeBase /// Adjusts the height of the row based on its contents, starting from the startColumn. /// /// The column to start calculating the row height. - IXLRow AdjustToContents(Int32 startColumn); + IXLRow AdjustToContents(int startColumn); /// /// Adjusts the height of the row based on its contents, starting from the startColumn and ending at endColumn. /// /// The column to start calculating the row height. /// The column to end calculating the row height. - IXLRow AdjustToContents(Int32 startColumn, Int32 endColumn); + IXLRow AdjustToContents(int startColumn, int endColumn); - IXLRow AdjustToContents(Double minHeight, Double maxHeight); + IXLRow AdjustToContents(double minHeight, double maxHeight); - IXLRow AdjustToContents(Int32 startColumn, Double minHeight, Double maxHeight); + IXLRow AdjustToContents(int startColumn, double minHeight, double maxHeight); - IXLRow AdjustToContents(Int32 startColumn, Int32 endColumn, Double minHeight, Double maxHeight); + IXLRow AdjustToContents(int startColumn, int endColumn, double minHeight, double maxHeight); /// Hides this row. IXLRow Hide(); @@ -74,7 +74,7 @@ public interface IXLRow : IXLRangeBase /// /// true if this row is hidden; otherwise, false. /// - Boolean IsHidden { get; } + bool IsHidden { get; } /// /// Gets or sets the outline level of this row. @@ -82,7 +82,7 @@ public interface IXLRow : IXLRangeBase /// /// The outline level of this row. /// - Int32 OutlineLevel { get; set; } + int OutlineLevel { get; set; } /// /// Adds this row to the next outline level (Increments the outline level for this row by 1). @@ -93,20 +93,20 @@ public interface IXLRow : IXLRangeBase /// Adds this row to the next outline level (Increments the outline level for this row by 1). /// /// If set to true the row will be shown collapsed. - IXLRow Group(Boolean collapse); + IXLRow Group(bool collapse); /// /// Sets outline level for this row. /// /// The outline level. - IXLRow Group(Int32 outlineLevel); + IXLRow Group(int outlineLevel); /// /// Sets outline level for this row. /// /// The outline level. /// If set to true the row will be shown collapsed. - IXLRow Group(Int32 outlineLevel, Boolean collapse); + IXLRow Group(int outlineLevel, bool collapse); /// /// Adds this row to the previous outline level (decrements the outline level for this row by 1). @@ -117,7 +117,7 @@ public interface IXLRow : IXLRangeBase /// Adds this row to the previous outline level (decrements the outline level for this row by 1). /// /// If set to true it will remove this row from all outline levels. - IXLRow Ungroup(Boolean fromAll); + IXLRow Ungroup(bool fromAll); /// /// Show this row as collapsed. @@ -128,39 +128,39 @@ public interface IXLRow : IXLRangeBase /// Gets the cell in the specified column. /// /// The cell's column. - IXLCell Cell(Int32 columnNumber); + IXLCell Cell(int columnNumber); /// /// Gets the cell in the specified column. /// /// The cell's column. - IXLCell Cell(String columnLetter); + IXLCell Cell(string columnLetter); /// /// Returns the specified group of cells, separated by commas. /// e.g. Cells("1"), Cells("1:5"), Cells("1,3:5") /// /// The row's cells to return. - new IXLCells Cells(String cellsInRow); + new IXLCells Cells(string cellsInRow); /// /// Returns the specified group of cells. /// /// The first column in the group of cells to return. /// The last column in the group of cells to return. - IXLCells Cells(Int32 firstColumn, Int32 lastColumn); + IXLCells Cells(int firstColumn, int lastColumn); /// /// Returns the specified group of cells. /// /// The first column in the group of cells to return. /// The last column in the group of cells to return. - IXLCells Cells(String firstColumn, String lastColumn); + IXLCells Cells(string firstColumn, string lastColumn); /// Expands this row (if it's collapsed). IXLRow Expand(); - Int32 CellCount(); + int CellCount(); IXLRangeRow CopyTo(IXLCell cell); @@ -170,13 +170,13 @@ public interface IXLRow : IXLRangeBase IXLRow Sort(); - IXLRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + IXLRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); - IXLRangeRow Row(Int32 start, Int32 end); + IXLRangeRow Row(int start, int end); IXLRangeRow Row(IXLCell start, IXLCell end); - IXLRangeRows Rows(String columns); + IXLRangeRows Rows(string columns); /// /// Adds a horizontal page break after this row. @@ -187,11 +187,11 @@ public interface IXLRow : IXLRangeBase IXLRow RowAbove(); - IXLRow RowAbove(Int32 step); + IXLRow RowAbove(int step); IXLRow RowBelow(); - IXLRow RowBelow(Int32 step); + IXLRow RowBelow(int step); /// /// Clears the contents of this row. @@ -200,7 +200,7 @@ public interface IXLRow : IXLRangeBase new IXLRow Clear(XLClearOptions clearOptions = XLClearOptions.All); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRangeRow RowUsed(Boolean includeFormats); + IXLRangeRow RowUsed(bool includeFormats); IXLRangeRow RowUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents); } diff --git a/ClosedXML/Excel/Rows/IXLRows.cs b/ClosedXML/Excel/Rows/IXLRows.cs index bf8adf752..e83c3821b 100644 --- a/ClosedXML/Excel/Rows/IXLRows.cs +++ b/ClosedXML/Excel/Rows/IXLRows.cs @@ -11,7 +11,7 @@ public interface IXLRows : IEnumerable /// /// The height of all rows. /// - Double Height { set; } + double Height { set; } /// /// Deletes all rows and shifts the rows below them accordingly. @@ -27,20 +27,20 @@ public interface IXLRows : IEnumerable /// Adjusts the height of all rows based on its contents, starting from the startColumn. /// /// The column to start calculating the row height. - IXLRows AdjustToContents(Int32 startColumn); + IXLRows AdjustToContents(int startColumn); /// /// Adjusts the height of all rows based on its contents, starting from the startColumn and ending at endColumn. /// /// The column to start calculating the row height. /// The column to end calculating the row height. - IXLRows AdjustToContents(Int32 startColumn, Int32 endColumn); + IXLRows AdjustToContents(int startColumn, int endColumn); - IXLRows AdjustToContents(Double minHeight, Double maxHeight); + IXLRows AdjustToContents(double minHeight, double maxHeight); - IXLRows AdjustToContents(Int32 startColumn, Double minHeight, Double maxHeight); + IXLRows AdjustToContents(int startColumn, double minHeight, double maxHeight); - IXLRows AdjustToContents(Int32 startColumn, Int32 endColumn, Double minHeight, Double maxHeight); + IXLRows AdjustToContents(int startColumn, int endColumn, double minHeight, double maxHeight); /// /// Hides all rows. @@ -59,20 +59,20 @@ public interface IXLRows : IEnumerable /// Increments the outline level of all rows by 1. /// /// If set to true the rows will be shown collapsed. - void Group(Boolean collapse); + void Group(bool collapse); /// /// Sets outline level for all rows. /// /// The outline level. - void Group(Int32 outlineLevel); + void Group(int outlineLevel); /// /// Sets outline level for all rows. /// /// The outline level. /// If set to true the rows will be shown collapsed. - void Group(Int32 outlineLevel, Boolean collapse); + void Group(int outlineLevel, bool collapse); /// /// Decrements the outline level of all rows by 1. @@ -83,7 +83,7 @@ public interface IXLRows : IEnumerable /// Decrements the outline level of all rows by 1. /// /// If set to true it will remove the rows from all outline levels. - void Ungroup(Boolean fromAll); + void Ungroup(bool fromAll); /// /// Show all rows as collapsed. @@ -108,7 +108,7 @@ public interface IXLRows : IEnumerable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); diff --git a/ClosedXML/Excel/Rows/XLRow.cs b/ClosedXML/Excel/Rows/XLRow.cs index 26840bdc4..b118e090d 100644 --- a/ClosedXML/Excel/Rows/XLRow.cs +++ b/ClosedXML/Excel/Rows/XLRow.cs @@ -1,6 +1,9 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Style; +using ClosedXML.Extensions; +using SkiaSharp; using System; using System.Collections.Generic; -using System.Drawing; using System.Linq; namespace ClosedXML.Excel @@ -9,8 +12,8 @@ internal class XLRow : XLRangeBase, IXLRow { #region Private fields - private Double _height; - private Int32 _outlineLevel; + private double _height; + private int _outlineLevel; #endregion Private fields @@ -19,7 +22,7 @@ internal class XLRow : XLRangeBase, IXLRow /// /// The direct contructor should only be used in . /// - public XLRow(XLWorksheet worksheet, Int32 row) + public XLRow(XLWorksheet worksheet, int row) : base(XLRangeAddress.EntireRow(worksheet, row), worksheet.StyleValue) { SetRowNumber(row); @@ -29,10 +32,7 @@ public XLRow(XLWorksheet worksheet, Int32 row) #endregion Constructor - public override XLRangeType RangeType - { - get { return XLRangeType.Row; } - } + public override XLRangeType RangeType => XLRangeType.Row; public override IEnumerable Styles { @@ -40,10 +40,12 @@ public override IEnumerable Styles { yield return Style; - int row = RowNumber(); + var row = RowNumber(); - foreach (XLCell cell in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + foreach (var cell in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + { yield return cell.Style; + } } } @@ -51,28 +53,32 @@ protected override IEnumerable Children { get { - int row = RowNumber(); + var row = RowNumber(); - foreach (XLCell cell in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + foreach (var cell in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + { yield return cell; + } } } - public Boolean Collapsed { get; set; } + public bool Collapsed { get; set; } #region IXLRow Members - public Boolean Loading { get; set; } + public bool Loading { get; set; } - public Boolean HeightChanged { get; private set; } + public bool HeightChanged { get; private set; } - public Double Height + public double Height { get { return _height; } set { if (!Loading) + { HeightChanged = true; + } _height = value; } @@ -86,14 +92,14 @@ public void ClearHeight() public void Delete() { - int rowNumber = RowNumber(); + var rowNumber = RowNumber(); AsRange().Delete(XLShiftDeletedCells.ShiftCellsUp); Worksheet.DeleteRow(rowNumber); } - public new IXLRows InsertRowsBelow(Int32 numberOfRows) + public new IXLRows InsertRowsBelow(int numberOfRows) { - int rowNum = RowNumber(); + var rowNum = RowNumber(); Worksheet.Internals.RowsCollection.ShiftRowsDown(rowNum + 1, numberOfRows); var asRange = Worksheet.Row(rowNum).AsRange(); asRange.InsertRowsBelowVoid(true, numberOfRows); @@ -118,9 +124,9 @@ private void CopyRows(IXLRows newRows) } } - public new IXLRows InsertRowsAbove(Int32 numberOfRows) + public new IXLRows InsertRowsAbove(int numberOfRows) { - int rowNum = RowNumber(); + var rowNum = RowNumber(); if (rowNum > 1) { return Worksheet.Row(rowNum - 1).InsertRowsBelow(numberOfRows); @@ -139,12 +145,12 @@ private void CopyRows(IXLRows newRows) return this; } - public IXLCell Cell(Int32 columnNumber) + public IXLCell Cell(int columnNumber) { return Cell(1, columnNumber); } - public override XLCell Cell(String columnLetter) + public override XLCell Cell(string columnLetter) { return Cell(1, columnLetter); } @@ -159,119 +165,142 @@ public override IXLCells Cells() return Cells(true, XLCellsUsedOptions.All); } - public override IXLCells Cells(Boolean usedCellsOnly) + public override IXLCells Cells(bool usedCellsOnly) { if (usedCellsOnly) + { return Cells(true, XLCellsUsedOptions.AllContents); + } else + { return Cells(FirstCellUsed().Address.ColumnNumber, LastCellUsed().Address.ColumnNumber); + } } - public override IXLCells Cells(String cellsInRow) + public override IXLCells Cells(string cellsInRow) { var retVal = new XLCells(false, XLCellsUsedOptions.AllContents); var rangePairs = cellsInRow.Split(','); - foreach (string pair in rangePairs) + foreach (var pair in rangePairs) + { retVal.Add(Range(pair.Trim()).RangeAddress); + } + return retVal; } - public IXLCells Cells(Int32 firstColumn, Int32 lastColumn) + public IXLCells Cells(int firstColumn, int lastColumn) { return Cells(firstColumn + ":" + lastColumn); } - public IXLCells Cells(String firstColumn, String lastColumn) + public IXLCells Cells(string firstColumn, string lastColumn) { return Cells(XLHelper.GetColumnNumberFromLetter(firstColumn) + ":" + XLHelper.GetColumnNumberFromLetter(lastColumn)); } - public IXLRow AdjustToContents(Int32 startColumn) + public IXLRow AdjustToContents(int startColumn) { return AdjustToContents(startColumn, XLHelper.MaxColumnNumber); } - public IXLRow AdjustToContents(Int32 startColumn, Int32 endColumn) + public IXLRow AdjustToContents(int startColumn, int endColumn) { - return AdjustToContents(startColumn, endColumn, 0, Double.MaxValue); + return AdjustToContents(startColumn, endColumn, 0, double.MaxValue); } - public IXLRow AdjustToContents(Double minHeight, Double maxHeight) + public IXLRow AdjustToContents(double minHeight, double maxHeight) { return AdjustToContents(1, XLHelper.MaxColumnNumber, minHeight, maxHeight); } - public IXLRow AdjustToContents(Int32 startColumn, Double minHeight, Double maxHeight) + public IXLRow AdjustToContents(int startColumn, double minHeight, double maxHeight) { return AdjustToContents(startColumn, XLHelper.MaxColumnNumber, minHeight, maxHeight); } - public IXLRow AdjustToContents(Int32 startColumn, Int32 endColumn, Double minHeight, Double maxHeight) + public IXLRow AdjustToContents(int startColumn, int endColumn, double minHeight, double maxHeight) { - var fontCache = new Dictionary(); + var fontCache = new Dictionary(); - Double rowMaxHeight = minHeight; - foreach (XLCell c in from XLCell c in Row(startColumn, endColumn).CellsUsed() where !c.IsMerged() select c) + var rowMaxHeight = minHeight; + foreach (var c in from XLCell c in Row(startColumn, endColumn).CellsUsed() where !c.IsMerged() select c) { - Double thisHeight; - Int32 textRotation = c.StyleValue.Alignment.TextRotation; - if (c.HasRichText || textRotation != 0 || c.InnerText.Contains(Environment.NewLine)) + double thisHeight; + var textRotation = c.StyleValue.Alignment.TextRotation; + if (c.HasRichText || textRotation != 0 || c.InnerText.Contains(XLConstants.NewLine)) { var kpList = new List>(); if (c.HasRichText) { - foreach (IXLRichString rt in c.GetRichText()) + foreach (var rt in c.GetRichText()) { - String formattedString = rt.Text; - var arr = formattedString.Split(new[] { Environment.NewLine }, StringSplitOptions.None); - Int32 arrCount = arr.Count(); - for (Int32 i = 0; i < arrCount; i++) + var formattedString = rt.Text; + var arr = formattedString.Split(new[] { XLConstants.NewLine }, StringSplitOptions.None); + var arrCount = arr.Length; + for (var i = 0; i < arrCount; i++) { - String s = arr[i]; + var s = arr[i]; if (i < arrCount - 1) - s += Environment.NewLine; - kpList.Add(new KeyValuePair(rt, s)); + { + s += XLConstants.NewLine; + } + + kpList.Add(new KeyValuePair(rt, s)); } } } else { - String formattedString = c.GetFormattedString(); - var arr = formattedString.Split(new[] { Environment.NewLine }, StringSplitOptions.None); - Int32 arrCount = arr.Count(); - for (Int32 i = 0; i < arrCount; i++) + var formattedString = c.GetFormattedString(); + var arr = formattedString.Split(new[] { XLConstants.NewLine }, StringSplitOptions.None); + var arrCount = arr.Length; + for (var i = 0; i < arrCount; i++) { - String s = arr[i]; + var s = arr[i]; if (i < arrCount - 1) - s += Environment.NewLine; - kpList.Add(new KeyValuePair(c.Style.Font, s)); + { + s += XLConstants.NewLine; + } + + kpList.Add(new KeyValuePair(c.Style.Font, s)); } } - Double maxLongCol = kpList.Max(kp => kp.Value.Length); - Double maxHeightCol = kpList.Max(kp => kp.Key.GetHeight(fontCache)); - Int32 lineCount = kpList.Count(kp => kp.Value.Contains(Environment.NewLine)) + 1; + double maxLongCol = kpList.Max(kp => kp.Value.Length); + var maxHeightCol = kpList.Max(kp => kp.Key.GetHeight(fontCache)); + var lineCount = kpList.Count(kp => kp.Value.Contains(XLConstants.NewLine)) + 1; if (textRotation == 0) + { thisHeight = maxHeightCol * lineCount; + } else { if (textRotation == 255) + { thisHeight = maxLongCol * maxHeightCol; + } else { - Double rotation; + double rotation; if (textRotation == 90 || textRotation == 180) + { rotation = 90; + } else + { rotation = textRotation % 90; + } - thisHeight = (rotation / 90.0) * maxHeightCol * maxLongCol * 0.5; + thisHeight = rotation / 90.0 * maxHeightCol * maxLongCol * 0.5; } } } else + { thisHeight = c.Style.Font.GetHeight(fontCache); + } if (thisHeight >= maxHeight) { @@ -279,11 +308,15 @@ public IXLRow AdjustToContents(Int32 startColumn, Int32 endColumn, Double minHei break; } if (thisHeight > rowMaxHeight) + { rowMaxHeight = thisHeight; + } } if (rowMaxHeight <= 0) + { rowMaxHeight = Worksheet.RowHeight; + } Height = rowMaxHeight; @@ -306,15 +339,17 @@ public IXLRow Unhide() return this; } - public Boolean IsHidden { get; set; } + public bool IsHidden { get; set; } - public Int32 OutlineLevel + public int OutlineLevel { get { return _outlineLevel; } set { if (value < 0 || value > 8) + { throw new ArgumentOutOfRangeException("value", "Outline level must be between 0 and 8."); + } Worksheet.IncrementColumnOutline(value); Worksheet.DecrementColumnOutline(_outlineLevel); @@ -327,7 +362,7 @@ public IXLRow Group() return Group(false); } - public IXLRow Group(Int32 outlineLevel) + public IXLRow Group(int outlineLevel) { return Group(outlineLevel, false); } @@ -337,30 +372,36 @@ public IXLRow Ungroup() return Ungroup(false); } - public IXLRow Group(Boolean collapse) + public IXLRow Group(bool collapse) { if (OutlineLevel < 8) + { OutlineLevel += 1; + } Collapsed = collapse; return this; } - public IXLRow Group(Int32 outlineLevel, Boolean collapse) + public IXLRow Group(int outlineLevel, bool collapse) { OutlineLevel = outlineLevel; Collapsed = collapse; return this; } - public IXLRow Ungroup(Boolean ungroupFromAll) + public IXLRow Ungroup(bool ungroupFromAll) { if (ungroupFromAll) + { OutlineLevel = 0; + } else { if (OutlineLevel > 0) + { OutlineLevel -= 1; + } } return this; } @@ -377,7 +418,7 @@ public IXLRow Expand() return Unhide(); } - public Int32 CellCount() + public int CellCount() { return RangeAddress.LastAddress.ColumnNumber - RangeAddress.FirstAddress.ColumnNumber + 1; } @@ -387,8 +428,8 @@ public Int32 CellCount() return SortLeftToRight(); } - public new IXLRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, - Boolean ignoreBlanks = true) + public new IXLRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, + bool ignoreBlanks = true) { base.SortLeftToRight(sortOrder, matchCase, ignoreBlanks); return this; @@ -420,7 +461,7 @@ public IXLRow CopyTo(IXLRow row) return newRow; } - public IXLRangeRow Row(Int32 start, Int32 end) + public IXLRangeRow Row(int start, int end) { return Range(1, start, 1, end).Row(1); } @@ -430,12 +471,14 @@ public IXLRangeRow Row(IXLCell start, IXLCell end) return Row(start.Address.ColumnNumber, end.Address.ColumnNumber); } - public IXLRangeRows Rows(String rows) + public IXLRangeRows Rows(string rows) { var retVal = new XLRangeRows(); var rowPairs = rows.Split(','); - foreach (string pair in rowPairs) + foreach (var pair in rowPairs) + { AsRange().Rows(pair.Trim()).ForEach(retVal.Add); + } return retVal; } @@ -453,7 +496,7 @@ public IXLRow SetDataType(XLDataType dataType) } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLRangeRow RowUsed(Boolean includeFormats) + public IXLRangeRow RowUsed(bool includeFormats) { return RowUsed(includeFormats ? XLCellsUsedOptions.All @@ -483,7 +526,7 @@ internal override void WorksheetRangeShiftedRows(XLRange range, int rowsShifted) return; // rows are shifted by XLRowCollection } - internal void SetRowNumber(Int32 row) + internal void SetRowNumber(int row) { RangeAddress = new XLRangeAddress( new XLAddress(Worksheet, row, 1, RangeAddress.FirstAddress.FixedRow, @@ -495,21 +538,25 @@ internal void SetRowNumber(Int32 row) RangeAddress.LastAddress.FixedColumn)); } - public override XLRange Range(String rangeAddressStr) + public override XLRange Range(string rangeAddressStr) { - String rangeAddressToUse; + string rangeAddressToUse; if (rangeAddressStr.Contains(':') || rangeAddressStr.Contains('-')) { if (rangeAddressStr.Contains('-')) + { rangeAddressStr = rangeAddressStr.Replace('-', ':'); + } var arrRange = rangeAddressStr.Split(':'); - string firstPart = arrRange[0]; - string secondPart = arrRange[1]; + var firstPart = arrRange[0]; + var secondPart = arrRange[1]; rangeAddressToUse = FixRowAddress(firstPart) + ":" + FixRowAddress(secondPart); } else + { rangeAddressToUse = FixRowAddress(rangeAddressStr); + } var rangeAddress = new XLRangeAddress(Worksheet, rangeAddressToUse); return Range(rangeAddress); @@ -524,12 +571,14 @@ internal void SetStyleNoColumns(IXLStyle value) { InnerStyle = value; - int row = RowNumber(); - foreach (XLCell c in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + var row = RowNumber(); + foreach (var c in Worksheet.Internals.CellsCollection.GetCellsInRow(row)) + { c.InnerStyle = value; + } } - private XLRow RowShift(Int32 rowsToShift) + private XLRow RowShift(int rowsToShift) { return Worksheet.Row(RowNumber() + rowsToShift); } @@ -541,7 +590,7 @@ IXLRow IXLRow.RowAbove() return RowAbove(); } - IXLRow IXLRow.RowAbove(Int32 step) + IXLRow IXLRow.RowAbove(int step) { return RowAbove(step); } @@ -551,7 +600,7 @@ public XLRow RowAbove() return RowAbove(1); } - public XLRow RowAbove(Int32 step) + public XLRow RowAbove(int step) { return RowShift(step * -1); } @@ -565,7 +614,7 @@ IXLRow IXLRow.RowBelow() return RowBelow(); } - IXLRow IXLRow.RowBelow(Int32 step) + IXLRow IXLRow.RowBelow(int step) { return RowBelow(step); } @@ -575,35 +624,37 @@ public XLRow RowBelow() return RowBelow(1); } - public XLRow RowBelow(Int32 step) + public XLRow RowBelow(int step) { return RowShift(step); } #endregion XLRow Below - public override Boolean IsEmpty() + public override bool IsEmpty() { return IsEmpty(XLCellsUsedOptions.AllContents); } - public override Boolean IsEmpty(XLCellsUsedOptions options) + public override bool IsEmpty(XLCellsUsedOptions options) { if (options.HasFlag(XLCellsUsedOptions.NormalFormats) && !StyleValue.Equals(Worksheet.StyleValue)) + { return false; + } return base.IsEmpty(options); } - public override Boolean IsEntireRow() + public override bool IsEntireRow() { return true; } - public override Boolean IsEntireColumn() + public override bool IsEntireColumn() { return false; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Rows/XLRowCollection.cs b/ClosedXML/Excel/Rows/XLRowCollection.cs index 1059b3ad1..af69c6d0f 100644 --- a/ClosedXML/Excel/Rows/XLRowCollection.cs +++ b/ClosedXML/Excel/Rows/XLRowCollection.cs @@ -1,27 +1,31 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; namespace ClosedXML.Excel { - using System.Collections; - - internal class XLRowsCollection : IDictionary + internal class XLRowsCollection : IDictionary { - private readonly Dictionary _dictionary = new Dictionary(); + private readonly Dictionary _dictionary = new Dictionary(); - public Dictionary Deleted { get; } = new Dictionary(); + public Dictionary Deleted { get; } = new Dictionary(); - public Int32 MaxRowUsed; + public int MaxRowUsed; #region IDictionary Members public void Add(int key, XLRow value) { - if (key > MaxRowUsed) MaxRowUsed = key; + if (key > MaxRowUsed) + { + MaxRowUsed = key; + } if (Deleted.ContainsKey(key)) + { Deleted.Remove(key); + } _dictionary.Add(key, value); } @@ -31,15 +35,14 @@ public bool ContainsKey(int key) return _dictionary.ContainsKey(key); } - public ICollection Keys - { - get { return _dictionary.Keys; } - } + public ICollection Keys => _dictionary.Keys; public bool Remove(int key) { if (!Deleted.ContainsKey(key)) + { Deleted.Add(key, _dictionary[key]); + } return _dictionary.Remove(key); } @@ -49,10 +52,7 @@ public bool TryGetValue(int key, out XLRow value) return _dictionary.TryGetValue(key, out value); } - public ICollection Values - { - get { return _dictionary.Values; } - } + public ICollection Values => _dictionary.Values; public XLRow this[int key] { @@ -62,10 +62,15 @@ public XLRow this[int key] public void Add(KeyValuePair item) { - if (item.Key > MaxRowUsed) MaxRowUsed = item.Key; + if (item.Key > MaxRowUsed) + { + MaxRowUsed = item.Key; + } if (Deleted.ContainsKey(item.Key)) + { Deleted.Remove(item.Key); + } _dictionary.Add(item.Key, item.Value); } @@ -85,20 +90,16 @@ public void CopyTo(KeyValuePair[] array, int arrayIndex) throw new NotImplementedException(); } - public int Count - { - get { return _dictionary.Count; } - } + public int Count => _dictionary.Count; - public bool IsReadOnly - { - get { return false; } - } + public bool IsReadOnly => false; public bool Remove(KeyValuePair item) { if (!Deleted.ContainsKey(item.Key)) + { Deleted.Add(item.Key, _dictionary[item.Key]); + } return _dictionary.Remove(item.Key); } @@ -115,13 +116,13 @@ IEnumerator IEnumerable.GetEnumerator() #endregion IDictionary Members - public void ShiftRowsDown(Int32 startingRow, Int32 rowsToShift) + public void ShiftRowsDown(int startingRow, int rowsToShift) { - foreach (int ro in _dictionary.Keys.Where(k => k >= startingRow).OrderByDescending(k => k)) + foreach (var ro in _dictionary.Keys.Where(k => k >= startingRow).OrderByDescending(k => k)) { var rowToMove = _dictionary[ro]; _dictionary.Remove(ro); - Int32 newRowNum = ro + rowsToShift; + var newRowNum = ro + rowsToShift; if (newRowNum <= XLHelper.MaxRowNumber) { rowToMove.SetRowNumber(newRowNum); @@ -130,7 +131,7 @@ public void ShiftRowsDown(Int32 startingRow, Int32 rowsToShift) } } - public void RemoveAll(Func predicate) + public void RemoveAll(Func predicate) { foreach (var row in _dictionary.Values.Where(predicate).Where(row1 => !Deleted.ContainsKey(row1.RowNumber()))) { diff --git a/ClosedXML/Excel/Rows/XLRows.cs b/ClosedXML/Excel/Rows/XLRows.cs index f4d744b90..eccd499a1 100644 --- a/ClosedXML/Excel/Rows/XLRows.cs +++ b/ClosedXML/Excel/Rows/XLRows.cs @@ -1,11 +1,11 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; +using ClosedXML.Excel.Style; namespace ClosedXML.Excel { - using System.Collections; - internal class XLRows : XLStylizedBase, IXLRows, IXLStylized { private readonly List _rowsCollection = new List(); @@ -48,7 +48,11 @@ public double Height set { Rows.ForEach(c => c.Height = value); - if (_worksheet == null) return; + if (_worksheet == null) + { + return; + } + _worksheet.RowHeight = value; _worksheet.Internals.RowsCollection.ForEach(r => r.Value.Height = value); } @@ -63,22 +67,24 @@ public void Delete() } else { - var toDelete = new Dictionary>(); - foreach (XLRow r in Rows) + var toDelete = new Dictionary>(); + foreach (var r in Rows) { - if (!toDelete.TryGetValue(r.Worksheet, out List list)) + if (!toDelete.TryGetValue(r.Worksheet, out var list)) { - list = new List(); + list = new List(); toDelete.Add(r.Worksheet, list); } list.Add(r.RowNumber()); } - foreach (KeyValuePair> kp in toDelete) + foreach (var kp in toDelete) { - foreach (int r in kp.Value.OrderByDescending(r => r)) + foreach (var r in kp.Value.OrderByDescending(r => r)) + { kp.Key.Row(r).Delete(); + } } } } @@ -89,31 +95,31 @@ public IXLRows AdjustToContents() return this; } - public IXLRows AdjustToContents(Int32 startColumn) + public IXLRows AdjustToContents(int startColumn) { Rows.ForEach(r => r.AdjustToContents(startColumn)); return this; } - public IXLRows AdjustToContents(Int32 startColumn, Int32 endColumn) + public IXLRows AdjustToContents(int startColumn, int endColumn) { Rows.ForEach(r => r.AdjustToContents(startColumn, endColumn)); return this; } - public IXLRows AdjustToContents(Double minHeight, Double maxHeight) + public IXLRows AdjustToContents(double minHeight, double maxHeight) { Rows.ForEach(r => r.AdjustToContents(minHeight, maxHeight)); return this; } - public IXLRows AdjustToContents(Int32 startColumn, Double minHeight, Double maxHeight) + public IXLRows AdjustToContents(int startColumn, double minHeight, double maxHeight) { Rows.ForEach(r => r.AdjustToContents(startColumn, minHeight, maxHeight)); return this; } - public IXLRows AdjustToContents(Int32 startColumn, Int32 endColumn, Double minHeight, Double maxHeight) + public IXLRows AdjustToContents(int startColumn, int endColumn, double minHeight, double maxHeight) { Rows.ForEach(r => r.AdjustToContents(startColumn, endColumn, minHeight, maxHeight)); return this; @@ -134,7 +140,7 @@ public void Group() Group(false); } - public void Group(Int32 outlineLevel) + public void Group(int outlineLevel) { Group(outlineLevel, false); } @@ -144,17 +150,17 @@ public void Ungroup() Ungroup(false); } - public void Group(Boolean collapse) + public void Group(bool collapse) { Rows.ForEach(r => r.Group(collapse)); } - public void Group(Int32 outlineLevel, Boolean collapse) + public void Group(int outlineLevel, bool collapse) { Rows.ForEach(r => r.Group(outlineLevel, collapse)); } - public void Ungroup(Boolean ungroupFromAll) + public void Ungroup(bool ungroupFromAll) { Rows.ForEach(r => r.Ungroup(ungroupFromAll)); } @@ -172,21 +178,27 @@ public void Expand() public IXLCells Cells() { var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - foreach (XLRow container in Rows) + foreach (var container in Rows) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(true, XLCellsUsedOptions.AllContents); - foreach (XLRow container in Rows) + foreach (var container in Rows) + { cells.Add(container.RangeAddress); + } + return cells; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -196,15 +208,21 @@ public IXLCells CellsUsed(Boolean includeFormats) public IXLCells CellsUsed(XLCellsUsedOptions options) { var cells = new XLCells(true, options); - foreach (XLRow container in Rows) + foreach (var container in Rows) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLRows AddHorizontalPageBreaks() { - foreach (XLRow row in Rows) + foreach (var row in Rows) + { row.Worksheet.PageSetup.AddHorizontalPageBreak(row.RowNumber()); + } + return this; } @@ -222,11 +240,15 @@ protected override IEnumerable Children get { if (_worksheet != null) + { yield return _worksheet; + } else { - foreach (XLRow row in Rows) + foreach (var row in Rows) + { yield return row; + } } } } @@ -237,10 +259,12 @@ public override IEnumerable Styles { yield return Style; if (_worksheet != null) + { yield return _worksheet.Style; + } else { - foreach (IXLStyle s in Rows.SelectMany(row => row.Styles)) + foreach (var s in Rows.SelectMany(row => row.Styles)) { yield return s; } @@ -275,13 +299,17 @@ public IXLRows Clear(XLClearOptions clearOptions = XLClearOptions.All) public void Select() { foreach (var range in this) + { range.Select(); + } } private void Materialize() { if (IsMaterialized) + { return; + } _rowsCollection.AddRange(Rows); _lazyEnumerable = null; diff --git a/ClosedXML/Excel/SaveOptions.cs b/ClosedXML/Excel/SaveOptions.cs index 83cf9821a..deab0622b 100644 --- a/ClosedXML/Excel/SaveOptions.cs +++ b/ClosedXML/Excel/SaveOptions.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -8,22 +7,22 @@ public class SaveOptions public SaveOptions() { #if DEBUG - this.ValidatePackage = true; + ValidatePackage = true; #else this.ValidatePackage = false; #endif } - public Boolean ConsolidateConditionalFormatRanges { get; set; } = true; - public Boolean ConsolidateDataValidationRanges { get; set; } = true; - public Boolean EvaluateFormulasBeforeSaving { get; set; } = false; + public bool ConsolidateConditionalFormatRanges { get; set; } = true; + public bool ConsolidateDataValidationRanges { get; set; } = true; + public bool EvaluateFormulasBeforeSaving { get; set; } /// /// Gets or sets the filter privacy flag. Set to null to leave the current property in saved workbook unchanged /// - public Boolean? FilterPrivacy { get; set; } + public bool? FilterPrivacy { get; set; } - public Boolean GenerateCalculationChain { get; set; } = true; - public Boolean ValidatePackage { get; set; } + public bool GenerateCalculationChain { get; set; } = true; + public bool ValidatePackage { get; set; } } } diff --git a/ClosedXML/Excel/Sparkline/IXLSparkLineGroup.cs b/ClosedXML/Excel/Sparkline/IXLSparkLineGroup.cs index e3ad63158..f6d9d2e70 100644 --- a/ClosedXML/Excel/Sparkline/IXLSparkLineGroup.cs +++ b/ClosedXML/Excel/Sparkline/IXLSparkLineGroup.cs @@ -46,11 +46,11 @@ public interface IXLSparklineGroup : IEnumerable XLDisplayBlanksAsValues DisplayEmptyCellsAs { get; set; } - Boolean DisplayHidden { get; set; } + bool DisplayHidden { get; set; } IXLSparklineHorizontalAxis HorizontalAxis { get; } - Double LineWeight { get; set; } + double LineWeight { get; set; } XLSparklineMarkers ShowMarkers { get; set; } @@ -90,9 +90,9 @@ public interface IXLSparklineGroup : IEnumerable IXLSparklineGroup SetDisplayEmptyCellsAs(XLDisplayBlanksAsValues value); - IXLSparklineGroup SetDisplayHidden(Boolean value); + IXLSparklineGroup SetDisplayHidden(bool value); - IXLSparklineGroup SetLineWeight(Double value); + IXLSparklineGroup SetLineWeight(double value); IXLSparklineGroup SetShowMarkers(XLSparklineMarkers value); diff --git a/ClosedXML/Excel/Sparkline/IXLSparklineHorizontalAxis.cs b/ClosedXML/Excel/Sparkline/IXLSparklineHorizontalAxis.cs index 5d2873dfc..3a977405b 100644 --- a/ClosedXML/Excel/Sparkline/IXLSparklineHorizontalAxis.cs +++ b/ClosedXML/Excel/Sparkline/IXLSparklineHorizontalAxis.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -9,11 +8,11 @@ public interface IXLSparklineHorizontalAxis XLColor Color { get; set; } - Boolean DateAxis { get; } + bool DateAxis { get; } - Boolean IsVisible { get; set; } + bool IsVisible { get; set; } - Boolean RightToLeft { get; set; } + bool RightToLeft { get; set; } #endregion Public Properties @@ -21,9 +20,9 @@ public interface IXLSparklineHorizontalAxis IXLSparklineHorizontalAxis SetColor(XLColor value); - IXLSparklineHorizontalAxis SetRightToLeft(Boolean value); + IXLSparklineHorizontalAxis SetRightToLeft(bool value); - IXLSparklineHorizontalAxis SetVisible(Boolean value); + IXLSparklineHorizontalAxis SetVisible(bool value); #endregion Public Methods } diff --git a/ClosedXML/Excel/Sparkline/IXLSparklineVerticalAxis.cs b/ClosedXML/Excel/Sparkline/IXLSparklineVerticalAxis.cs index 17e5d2633..c236d1bf8 100644 --- a/ClosedXML/Excel/Sparkline/IXLSparklineVerticalAxis.cs +++ b/ClosedXML/Excel/Sparkline/IXLSparklineVerticalAxis.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; namespace ClosedXML.Excel { @@ -7,9 +6,9 @@ public interface IXLSparklineVerticalAxis { #region Public Properties - Double? ManualMax { get; set; } + double? ManualMax { get; set; } - Double? ManualMin { get; set; } + double? ManualMin { get; set; } XLSparklineAxisMinMax MaxAxisType { get; set; } @@ -19,9 +18,9 @@ public interface IXLSparklineVerticalAxis #region Public Methods - IXLSparklineVerticalAxis SetManualMax(Double? value); + IXLSparklineVerticalAxis SetManualMax(double? value); - IXLSparklineVerticalAxis SetManualMin(Double? value); + IXLSparklineVerticalAxis SetManualMin(double? value); IXLSparklineVerticalAxis SetMaxAxisType(XLSparklineAxisMinMax value); diff --git a/ClosedXML/Excel/Sparkline/XLSparkLine.cs b/ClosedXML/Excel/Sparkline/XLSparkLine.cs index e2dbe3a76..61ad990bd 100644 --- a/ClosedXML/Excel/Sparkline/XLSparkLine.cs +++ b/ClosedXML/Excel/Sparkline/XLSparkLine.cs @@ -47,13 +47,19 @@ public IXLRange SourceData public XLSparkline(IXLSparklineGroup sparklineGroup, IXLCell cell, IXLRange sourceData) { if (sparklineGroup == null) + { throw new ArgumentNullException(nameof(sparklineGroup)); + } if (cell == null) + { throw new ArgumentNullException(nameof(cell)); + } if (sparklineGroup.Worksheet != cell.Worksheet) + { throw new InvalidOperationException("Cell must belong to the same worksheet as the sparkline group"); + } SparklineGroup = sparklineGroup; Location = cell; @@ -67,10 +73,14 @@ public XLSparkline(IXLSparklineGroup sparklineGroup, IXLCell cell, IXLRange sour public IXLSparkline SetLocation(IXLCell cell) { if (cell != null && cell.Worksheet != SparklineGroup.Worksheet) + { throw new InvalidOperationException("Cannot move the sparkline to a different worksheet"); + } if (_location != null) + { SparklineGroup.Remove(_location); + } _location = cell; (SparklineGroup as XLSparklineGroup).Add(this); @@ -80,7 +90,9 @@ public IXLSparkline SetLocation(IXLCell cell) public IXLSparkline SetSourceData(IXLRange range) { if (range != null && range.RowCount() != 1 && range.ColumnCount() != 1) + { throw new ArgumentException("SourceData range must have either a single row or a single column"); + } _sourceData = range; return this; diff --git a/ClosedXML/Excel/Sparkline/XLSparkLineGroup.cs b/ClosedXML/Excel/Sparkline/XLSparkLineGroup.cs index ba5847eca..74a2f9f95 100644 --- a/ClosedXML/Excel/Sparkline/XLSparkLineGroup.cs +++ b/ClosedXML/Excel/Sparkline/XLSparkLineGroup.cs @@ -18,11 +18,11 @@ public IXLRange DateRange public XLDisplayBlanksAsValues DisplayEmptyCellsAs { get; set; } - public Boolean DisplayHidden { get; set; } + public bool DisplayHidden { get; set; } public IXLSparklineHorizontalAxis HorizontalAxis { get; } - public Double LineWeight { get; set; } + public double LineWeight { get; set; } public XLSparklineMarkers ShowMarkers { get; set; } @@ -109,8 +109,11 @@ public IEnumerable Add(IXLRange locationRange, IXLRange sourceData else if (singleRow) { if (locationRange.ColumnCount() != sourceDataRange.ColumnCount()) + { throw new ArgumentException("locationRange and sourceDataRange must have the same width"); - for (int i = 1; i <= locationRange.ColumnCount(); i++) + } + + for (var i = 1; i <= locationRange.ColumnCount(); i++) { newSparklines.Add(Add(locationRange.Cell(1, i), sourceDataRange.Column(i).AsRange())); } @@ -118,15 +121,19 @@ public IEnumerable Add(IXLRange locationRange, IXLRange sourceData else if (singleColumn) { if (locationRange.RowCount() != sourceDataRange.RowCount()) + { throw new ArgumentException("locationRange and sourceDataRange must have the same height"); + } - for (int i = 1; i <= locationRange.RowCount(); i++) + for (var i = 1; i <= locationRange.RowCount(); i++) { newSparklines.Add(Add(locationRange.Cell(i, 1), sourceDataRange.Row(i).AsRange())); } } else + { throw new ArgumentException("locationRange must have either a single row or a single column"); + } return newSparklines; } @@ -141,7 +148,9 @@ public IEnumerable Add(IXLRange locationRange, IXLRange sourceData public IXLSparkline Add(IXLCell location, IXLRange sourceData) { if (location.Worksheet != Worksheet) + { throw new ArgumentException("The specified sparkline belongs to the different worksheet"); + } return new XLSparkline(this, location, sourceData); } @@ -184,8 +193,10 @@ public void CopyFrom(IXLSparklineGroup sparklineGroup) public IXLSparklineGroup CopyTo(IXLWorksheet targetSheet) { if (targetSheet == Worksheet) + { throw new InvalidOperationException( "Cannot copy the sparkline group to the same worksheet it belongs to"); + } var copy = targetSheet.SparklineGroups.Add(new XLSparklineGroup(targetSheet, this)); foreach (var sparkline in _sparklines.Values) @@ -212,7 +223,7 @@ IEnumerator IEnumerable.GetEnumerator() public IXLSparkline GetSparkline(IXLCell cell) { - return _sparklines.TryGetValue(cell, out IXLSparkline sparkline) ? sparkline : null; + return _sparklines.TryGetValue(cell, out var sparkline) ? sparkline : null; } public IEnumerable GetSparklines(IXLRangeBase searchRange) @@ -230,7 +241,9 @@ public IEnumerable GetSparklines(IXLRangeBase searchRange) public void Remove(IXLCell cell) { if (_sparklines.ContainsKey(cell)) + { _sparklines.Remove(cell); + } } /// @@ -252,10 +265,9 @@ public void RemoveAll() public IXLSparklineGroup SetDateRange(IXLRange value) { - if (value != null) + if (value != null && value.RowCount() != 1 && value.ColumnCount() != 1) { - if (value.RowCount() != 1 && value.ColumnCount() != 1) - throw new ArgumentException("The date range must be either one row high or one column wide"); + throw new ArgumentException("The date range must be either one row high or one column wide"); } _dateRange = value; @@ -268,13 +280,13 @@ public IXLSparklineGroup SetDisplayEmptyCellsAs(XLDisplayBlanksAsValues displayE return this; } - public IXLSparklineGroup SetDisplayHidden(Boolean displayHidden) + public IXLSparklineGroup SetDisplayHidden(bool displayHidden) { DisplayHidden = displayHidden; return this; } - public IXLSparklineGroup SetLineWeight(Double lineWeight) + public IXLSparklineGroup SetLineWeight(double lineWeight) { LineWeight = lineWeight; return this; @@ -301,7 +313,9 @@ public IXLSparklineGroup SetType(XLSparklineType type) internal IXLSparkline Add(IXLSparkline sparkline) { if (sparkline.Location.Worksheet != Worksheet) + { throw new ArgumentException("The specified sparkline belongs to the different worksheet"); + } SparklineGroups.Remove(sparkline.Location); _sparklines[sparkline.Location] = sparkline; @@ -335,4 +349,4 @@ internal XLSparklineGroup(IXLWorksheet targetWorksheet) #endregion Private Constructors } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Sparkline/XLSparkLineGroups.cs b/ClosedXML/Excel/Sparkline/XLSparkLineGroups.cs index daee483a7..289d39dd1 100644 --- a/ClosedXML/Excel/Sparkline/XLSparkLineGroups.cs +++ b/ClosedXML/Excel/Sparkline/XLSparkLineGroups.cs @@ -40,7 +40,9 @@ internal IXLSparklineGroup Add() public IXLSparklineGroup Add(IXLSparklineGroup sparklineGroup) { if (sparklineGroup.Worksheet != Worksheet) + { throw new ArgumentException("The specified sparkline group belongs to the different worksheet"); + } _sparklineGroups.Add(sparklineGroup); return sparklineGroup; diff --git a/ClosedXML/Excel/Sparkline/XLSparklineStyle.cs b/ClosedXML/Excel/Sparkline/XLSparklineStyle.cs index 1cdc30bfa..966e769e6 100644 --- a/ClosedXML/Excel/Sparkline/XLSparklineStyle.cs +++ b/ClosedXML/Excel/Sparkline/XLSparklineStyle.cs @@ -105,8 +105,16 @@ public static void Copy(IXLSparklineStyle from, IXLSparklineStyle to) /// true if the current object is equal to the other parameter; otherwise, false. public bool Equals(XLSparklineStyle other) { - if (ReferenceEquals(null, other)) return false; - if (ReferenceEquals(this, other)) return true; + if (other is null) + { + return false; + } + + if (ReferenceEquals(this, other)) + { + return true; + } + return FirstMarkerColor.Equals(other.FirstMarkerColor) && HighMarkerColor.Equals(other.HighMarkerColor) && LastMarkerColor.Equals(other.LastMarkerColor) @@ -121,9 +129,21 @@ public bool Equals(XLSparklineStyle other) /// true if the specified object is equal to the current object; otherwise, false. public override bool Equals(object obj) { - if (ReferenceEquals(null, obj)) return false; - if (ReferenceEquals(this, obj)) return true; - if (obj.GetType() != typeof(XLSparklineStyle)) return false; + if (obj is null) + { + return false; + } + + if (ReferenceEquals(this, obj)) + { + return true; + } + + if (obj.GetType() != typeof(XLSparklineStyle)) + { + return false; + } + return Equals((XLSparklineStyle)obj); } diff --git a/ClosedXML/Excel/Sparkline/XLSparklineVerticalAxis.cs b/ClosedXML/Excel/Sparkline/XLSparklineVerticalAxis.cs index 9831e47db..0277db9d2 100644 --- a/ClosedXML/Excel/Sparkline/XLSparklineVerticalAxis.cs +++ b/ClosedXML/Excel/Sparkline/XLSparklineVerticalAxis.cs @@ -7,13 +7,13 @@ internal class XLSparklineVerticalAxis : IXLSparklineVerticalAxis { #region Public Properties - public Double? ManualMax + public double? ManualMax { get => _manualMax; set => SetManualMax(value); } - public Double? ManualMin + public double? ManualMin { get => _manualMin; set => SetManualMin(value); @@ -35,19 +35,23 @@ public XLSparklineAxisMinMax MinAxisType #region Public Methods - public IXLSparklineVerticalAxis SetManualMax(Double? manualMax) + public IXLSparklineVerticalAxis SetManualMax(double? manualMax) { if (manualMax != null) + { MaxAxisType = XLSparklineAxisMinMax.Custom; + } _manualMax = manualMax; return this; } - public IXLSparklineVerticalAxis SetManualMin(Double? manualMin) + public IXLSparklineVerticalAxis SetManualMin(double? manualMin) { if (manualMin != null) + { MinAxisType = XLSparklineAxisMinMax.Custom; + } _manualMin = manualMin; return this; @@ -56,7 +60,9 @@ public IXLSparklineVerticalAxis SetManualMin(Double? manualMin) public IXLSparklineVerticalAxis SetMaxAxisType(XLSparklineAxisMinMax maxAxisType) { if (maxAxisType != XLSparklineAxisMinMax.Custom) + { _manualMax = null; + } _maxAxisType = maxAxisType; return this; @@ -65,7 +71,9 @@ public IXLSparklineVerticalAxis SetMaxAxisType(XLSparklineAxisMinMax maxAxisType public IXLSparklineVerticalAxis SetMinAxisType(XLSparklineAxisMinMax minAxisType) { if (minAxisType != XLSparklineAxisMinMax.Custom) + { _manualMin = null; + } _minAxisType = minAxisType; return this; @@ -75,8 +83,8 @@ public IXLSparklineVerticalAxis SetMinAxisType(XLSparklineAxisMinMax minAxisType #region Private Fields - private Double? _manualMax; - private Double? _manualMin; + private double? _manualMax; + private double? _manualMin; private XLSparklineAxisMinMax _maxAxisType; private XLSparklineAxisMinMax _minAxisType; diff --git a/ClosedXML/Excel/Style/Colors/XLColor_Internal.cs b/ClosedXML/Excel/Style/Colors/XLColor_Internal.cs index 3919bf8f2..ef3d07328 100644 --- a/ClosedXML/Excel/Style/Colors/XLColor_Internal.cs +++ b/ClosedXML/Excel/Style/Colors/XLColor_Internal.cs @@ -1,5 +1,4 @@ -using System; -using System.Drawing; +using SkiaSharp; namespace ClosedXML.Excel { @@ -16,7 +15,7 @@ private XLColor() : this(new XLColorKey()) HasValue = false; } - private XLColor(Color color) : this(new XLColorKey + private XLColor(SKColor color) : this(new XLColorKey { Color = color, ColorType = XLColorType.Color @@ -24,7 +23,7 @@ private XLColor(Color color) : this(new XLColorKey { } - private XLColor(Int32 index) : this(new XLColorKey + private XLColor(int index) : this(new XLColorKey { Indexed = index, ColorType = XLColorType.Indexed @@ -40,7 +39,7 @@ private XLColor(XLThemeColor themeColor) : this(new XLColorKey { } - private XLColor(XLThemeColor themeColor, Double themeTint) : this(new XLColorKey + private XLColor(XLThemeColor themeColor, double themeTint) : this(new XLColorKey { ThemeColor = themeColor, ThemeTint = themeTint, diff --git a/ClosedXML/Excel/Style/Colors/XLColor_Public.cs b/ClosedXML/Excel/Style/Colors/XLColor_Public.cs index a75edcf40..cfbad6f3e 100644 --- a/ClosedXML/Excel/Style/Colors/XLColor_Public.cs +++ b/ClosedXML/Excel/Style/Colors/XLColor_Public.cs @@ -1,5 +1,5 @@ +using SkiaSharp; using System; -using System.Drawing; namespace ClosedXML.Excel { @@ -34,41 +34,51 @@ public partial class XLColor : IEquatable /// Some people claim it's the index for tooltip color. /// We'll return normal black when index 81 is found. /// - private const Int32 TOOLTIPCOLORINDEX = 81; + private const int TOOLTIPCOLORINDEX = 81; - public Boolean HasValue { get; private set; } + public bool HasValue { get; private set; } - public XLColorType ColorType - { - get { return Key.ColorType; } - } + public XLColorType ColorType => Key.ColorType; - public Color Color + public SKColor Color { get { if (ColorType == XLColorType.Theme) + { throw new InvalidOperationException("Cannot convert theme color to Color."); + } if (ColorType == XLColorType.Indexed) + { if (Indexed == TOOLTIPCOLORINDEX) - return Color.FromArgb(255, Color.Black); + { + var tooltipColor = SKColors.Black.WithAlpha(255); + return tooltipColor; + } else + { return IndexedColors[Indexed].Color; + } + } return Key.Color; } } - public Int32 Indexed + public int Indexed { get { if (ColorType == XLColorType.Theme) + { throw new InvalidOperationException("Cannot convert theme color to indexed color."); + } if (ColorType == XLColorType.Indexed) + { return Key.Indexed; + } throw new InvalidOperationException("Cannot convert Color to indexed color."); } @@ -79,26 +89,34 @@ public XLThemeColor ThemeColor get { if (ColorType == XLColorType.Theme) + { return Key.ThemeColor; + } if (ColorType == XLColorType.Indexed) + { throw new InvalidOperationException("Cannot convert indexed color to theme color."); + } throw new InvalidOperationException("Cannot convert Color to theme color."); } } - public Double ThemeTint + public double ThemeTint { get { if (ColorType == XLColorType.Theme) + { return Key.ThemeTint; + } if (ColorType == XLColorType.Indexed) + { throw new InvalidOperationException("Cannot extract theme tint from an indexed color."); + } - return Color.A / 255.0; + return Color.Alpha / 255.0; } } @@ -127,28 +145,38 @@ public override int GetHashCode() public override string ToString() { if (ColorType == XLColorType.Color) + { return Color.ToHex(); + } if (ColorType == XLColorType.Theme) - return String.Format("Color Theme: {0}, Tint: {1}", ThemeColor.ToString(), ThemeTint.ToString()); + { + return $"Color Theme: {ThemeColor}, Tint: {ThemeTint}"; + } - return "Color Index: " + Indexed; + return $"Color Index: {Indexed}"; } - public static Boolean operator ==(XLColor left, XLColor right) + public static bool operator ==(XLColor left, XLColor right) { // If both are null, or both are same instance, return true. - if (ReferenceEquals(left, right)) return true; + if (ReferenceEquals(left, right)) + { + return true; + } // If one is null, but not both, return false. - if ((left as object) == null || (right as Object) == null) return false; + if ((left as object) == null || (right as object) == null) + { + return false; + } return left.Equals(right); } - public static Boolean operator !=(XLColor left, XLColor right) + public static bool operator !=(XLColor left, XLColor right) { return !(left == right); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Style/Colors/XLColor_Static.cs b/ClosedXML/Excel/Style/Colors/XLColor_Static.cs index 9fa5bc58e..93aff8758 100644 --- a/ClosedXML/Excel/Style/Colors/XLColor_Static.cs +++ b/ClosedXML/Excel/Style/Colors/XLColor_Static.cs @@ -1,8 +1,8 @@ using ClosedXML.Excel.Caching; using ClosedXML.Utils; -using System; +using DocumentFormat.OpenXml.Spreadsheet; +using SkiaSharp; using System.Collections.Generic; -using System.Drawing; namespace ClosedXML.Excel { @@ -10,15 +10,12 @@ public partial class XLColor { private static readonly XLColorRepository Repository = new XLColorRepository(key => new XLColor(key)); - private static readonly Dictionary ByColor = new Dictionary(); - private static readonly Object ByColorLock = new Object(); - internal static XLColor FromKey(ref XLColorKey key) { return Repository.GetOrCreate(ref key); } - public static XLColor FromColor(Color color) + public static XLColor FromColor(SKColor color) { var key = new XLColorKey { @@ -28,39 +25,42 @@ public static XLColor FromColor(Color color) return FromKey(ref key); } - public static XLColor FromArgb(Int32 argb) + public static XLColor FromColor(Color color) { - return FromColor(Color.FromArgb(argb)); + var key = new XLColorKey + { + ColorType = XLColorType.Color, + Color = SKColor.Parse(color.Rgb.Value) + }; + return FromKey(ref key); } - public static XLColor FromArgb(Int32 r, Int32 g, Int32 b) + public static XLColor FromArgb(int argb) { - return FromColor(Color.FromArgb(r, g, b)); + return FromColor(ColorStringParser.FromArgb(argb)); } - public static XLColor FromArgb(Int32 a, Int32 r, Int32 g, Int32 b) + public static XLColor FromArgb(int r, int g, int b) { - return FromColor(Color.FromArgb(a, r, g, b)); + return FromColor(ColorStringParser.FromArgb(r, g, b)); } -#if _NETFRAMEWORK_ - public static XLColor FromKnownColor(KnownColor color) + public static XLColor FromArgb(int a, int r, int g, int b) { - return FromColor(Color.FromKnownColor(color)); + return FromColor(ColorStringParser.FromArgb(a, r, g, b)); } -#endif - public static XLColor FromName(String name) + public static XLColor FromName(string name) { - return FromColor(Color.FromName(name)); + return FromColor(ColorStringParser.FromName(name)); } - public static XLColor FromHtml(String htmlColor) + public static XLColor FromHtml(string htmlColor) { return FromColor(ColorStringParser.ParseFromHtml(htmlColor)); } - public static XLColor FromIndex(Int32 index) + public static XLColor FromIndex(int index) { var key = new XLColorKey { @@ -80,7 +80,7 @@ public static XLColor FromTheme(XLThemeColor themeColor) return FromKey(ref key); } - public static XLColor FromTheme(XLThemeColor themeColor, Double themeTint) + public static XLColor FromTheme(XLThemeColor themeColor, double themeTint) { var key = new XLColorKey { @@ -91,15 +91,15 @@ public static XLColor FromTheme(XLThemeColor themeColor, Double themeTint) return FromKey(ref key); } - private static Dictionary _indexedColors; + private static Dictionary _indexedColors; - public static Dictionary IndexedColors + public static Dictionary IndexedColors { get { if (_indexedColors == null) { - var retVal = new Dictionary + var retVal = new Dictionary { {0, FromHtml("#FF000000")}, {1, FromHtml("#FFFFFFFF")}, @@ -165,7 +165,7 @@ public static Dictionary IndexedColors {61, FromHtml("#FF993366")}, {62, FromHtml("#FF333399")}, {63, FromHtml("#FF333333")}, - {64, FromColor(Color.Transparent)} + {64, FromColor(SKColors.Transparent)} }; _indexedColors = retVal; } @@ -188,1472 +188,1472 @@ internal static bool IsTransparent(in XLColorKey colorKey) public static XLColor NoColor { get; } = new XLColor(); - public static XLColor AliceBlue { get { return FromColor(Color.AliceBlue); } } + public static XLColor AliceBlue => FromColor(SKColors.AliceBlue); - public static XLColor AntiqueWhite { get { return FromColor(Color.AntiqueWhite); } } + public static XLColor AntiqueWhite => FromColor(SKColors.AntiqueWhite); - public static XLColor Aqua { get { return FromColor(Color.Aqua); } } + public static XLColor Aqua => FromColor(SKColors.Aqua); - public static XLColor Aquamarine { get { return FromColor(Color.Aquamarine); } } + public static XLColor Aquamarine => FromColor(SKColors.Aquamarine); - public static XLColor Azure { get { return FromColor(Color.Azure); } } + public static XLColor Azure => FromColor(SKColors.Azure); - public static XLColor Beige { get { return FromColor(Color.Beige); } } + public static XLColor Beige => FromColor(SKColors.Beige); - public static XLColor Bisque { get { return FromColor(Color.Bisque); } } + public static XLColor Bisque => FromColor(SKColors.Bisque); - public static XLColor Black { get { return FromColor(Color.Black); } } + public static XLColor Black => FromColor(SKColors.Black); - public static XLColor BlanchedAlmond { get { return FromColor(Color.BlanchedAlmond); } } + public static XLColor BlanchedAlmond => FromColor(SKColors.BlanchedAlmond); - public static XLColor Blue { get { return FromColor(Color.Blue); } } + public static XLColor Blue => FromColor(SKColors.Blue); - public static XLColor BlueViolet { get { return FromColor(Color.BlueViolet); } } + public static XLColor BlueViolet => FromColor(SKColors.BlueViolet); - public static XLColor Brown { get { return FromColor(Color.Brown); } } + public static XLColor Brown => FromColor(SKColors.Brown); - public static XLColor BurlyWood { get { return FromColor(Color.BurlyWood); } } + public static XLColor BurlyWood => FromColor(SKColors.BurlyWood); - public static XLColor CadetBlue { get { return FromColor(Color.CadetBlue); } } + public static XLColor CadetBlue => FromColor(SKColors.CadetBlue); - public static XLColor Chartreuse { get { return FromColor(Color.Chartreuse); } } + public static XLColor Chartreuse => FromColor(SKColors.Chartreuse); - public static XLColor Chocolate { get { return FromColor(Color.Chocolate); } } + public static XLColor Chocolate => FromColor(SKColors.Chocolate); - public static XLColor Coral { get { return FromColor(Color.Coral); } } + public static XLColor Coral => FromColor(SKColors.Coral); - public static XLColor CornflowerBlue { get { return FromColor(Color.CornflowerBlue); } } + public static XLColor CornflowerBlue => FromColor(SKColors.CornflowerBlue); - public static XLColor Cornsilk { get { return FromColor(Color.Cornsilk); } } + public static XLColor Cornsilk => FromColor(SKColors.Cornsilk); - public static XLColor Crimson { get { return FromColor(Color.Crimson); } } + public static XLColor Crimson => FromColor(SKColors.Crimson); - public static XLColor Cyan { get { return FromColor(Color.Cyan); } } + public static XLColor Cyan => FromColor(SKColors.Cyan); - public static XLColor DarkBlue { get { return FromColor(Color.DarkBlue); } } + public static XLColor DarkBlue => FromColor(SKColors.DarkBlue); - public static XLColor DarkCyan { get { return FromColor(Color.DarkCyan); } } + public static XLColor DarkCyan => FromColor(SKColors.DarkCyan); - public static XLColor DarkGoldenrod { get { return FromColor(Color.DarkGoldenrod); } } + public static XLColor DarkGoldenrod => FromColor(SKColors.DarkGoldenrod); - public static XLColor DarkGray { get { return FromColor(Color.DarkGray); } } + public static XLColor DarkGray => FromColor(SKColors.DarkGray); - public static XLColor DarkGreen { get { return FromColor(Color.DarkGreen); } } + public static XLColor DarkGreen => FromColor(SKColors.DarkGreen); - public static XLColor DarkKhaki { get { return FromColor(Color.DarkKhaki); } } + public static XLColor DarkKhaki => FromColor(SKColors.DarkKhaki); - public static XLColor DarkMagenta { get { return FromColor(Color.DarkMagenta); } } + public static XLColor DarkMagenta => FromColor(SKColors.DarkMagenta); - public static XLColor DarkOliveGreen { get { return FromColor(Color.DarkOliveGreen); } } + public static XLColor DarkOliveGreen => FromColor(SKColors.DarkOliveGreen); - public static XLColor DarkOrange { get { return FromColor(Color.DarkOrange); } } + public static XLColor DarkOrange => FromColor(SKColors.DarkOrange); - public static XLColor DarkOrchid { get { return FromColor(Color.DarkOrchid); } } + public static XLColor DarkOrchid => FromColor(SKColors.DarkOrchid); - public static XLColor DarkRed { get { return FromColor(Color.DarkRed); } } + public static XLColor DarkRed => FromColor(SKColors.DarkRed); - public static XLColor DarkSalmon { get { return FromColor(Color.DarkSalmon); } } + public static XLColor DarkSalmon => FromColor(SKColors.DarkSalmon); - public static XLColor DarkSeaGreen { get { return FromColor(Color.DarkSeaGreen); } } + public static XLColor DarkSeaGreen => FromColor(SKColors.DarkSeaGreen); - public static XLColor DarkSlateBlue { get { return FromColor(Color.DarkSlateBlue); } } + public static XLColor DarkSlateBlue => FromColor(SKColors.DarkSlateBlue); - public static XLColor DarkSlateGray { get { return FromColor(Color.DarkSlateGray); } } + public static XLColor DarkSlateGray => FromColor(SKColors.DarkSlateGray); - public static XLColor DarkTurquoise { get { return FromColor(Color.DarkTurquoise); } } + public static XLColor DarkTurquoise => FromColor(SKColors.DarkTurquoise); - public static XLColor DarkViolet { get { return FromColor(Color.DarkViolet); } } + public static XLColor DarkViolet => FromColor(SKColors.DarkViolet); - public static XLColor DeepPink { get { return FromColor(Color.DeepPink); } } + public static XLColor DeepPink => FromColor(SKColors.DeepPink); - public static XLColor DeepSkyBlue { get { return FromColor(Color.DeepSkyBlue); } } + public static XLColor DeepSkyBlue => FromColor(SKColors.DeepSkyBlue); - public static XLColor DimGray { get { return FromColor(Color.DimGray); } } + public static XLColor DimGray => FromColor(SKColors.DimGray); - public static XLColor DodgerBlue { get { return FromColor(Color.DodgerBlue); } } + public static XLColor DodgerBlue => FromColor(SKColors.DodgerBlue); - public static XLColor Firebrick { get { return FromColor(Color.Firebrick); } } + public static XLColor Firebrick => FromColor(SKColors.Firebrick); - public static XLColor FloralWhite { get { return FromColor(Color.FloralWhite); } } + public static XLColor FloralWhite => FromColor(SKColors.FloralWhite); - public static XLColor ForestGreen { get { return FromColor(Color.ForestGreen); } } + public static XLColor ForestGreen => FromColor(SKColors.ForestGreen); - public static XLColor Fuchsia { get { return FromColor(Color.Fuchsia); } } + public static XLColor Fuchsia => FromColor(SKColors.Fuchsia); - public static XLColor Gainsboro { get { return FromColor(Color.Gainsboro); } } + public static XLColor Gainsboro => FromColor(SKColors.Gainsboro); - public static XLColor GhostWhite { get { return FromColor(Color.GhostWhite); } } + public static XLColor GhostWhite => FromColor(SKColors.GhostWhite); - public static XLColor Gold { get { return FromColor(Color.Gold); } } + public static XLColor Gold => FromColor(SKColors.Gold); - public static XLColor Goldenrod { get { return FromColor(Color.Goldenrod); } } + public static XLColor Goldenrod => FromColor(SKColors.Goldenrod); - public static XLColor Gray { get { return FromColor(Color.Gray); } } + public static XLColor Gray => FromColor(SKColors.Gray); - public static XLColor Green { get { return FromColor(Color.Green); } } + public static XLColor Green => FromColor(SKColors.Green); - public static XLColor GreenYellow { get { return FromColor(Color.GreenYellow); } } + public static XLColor GreenYellow => FromColor(SKColors.GreenYellow); - public static XLColor Honeydew { get { return FromColor(Color.Honeydew); } } + public static XLColor Honeydew => FromColor(SKColors.Honeydew); - public static XLColor HotPink { get { return FromColor(Color.HotPink); } } + public static XLColor HotPink => FromColor(SKColors.HotPink); - public static XLColor IndianRed { get { return FromColor(Color.IndianRed); } } + public static XLColor IndianRed => FromColor(SKColors.IndianRed); - public static XLColor Indigo { get { return FromColor(Color.Indigo); } } + public static XLColor Indigo => FromColor(SKColors.Indigo); - public static XLColor Ivory { get { return FromColor(Color.Ivory); } } + public static XLColor Ivory => FromColor(SKColors.Ivory); - public static XLColor Khaki { get { return FromColor(Color.Khaki); } } + public static XLColor Khaki => FromColor(SKColors.Khaki); - public static XLColor Lavender { get { return FromColor(Color.Lavender); } } + public static XLColor Lavender => FromColor(SKColors.Lavender); - public static XLColor LavenderBlush { get { return FromColor(Color.LavenderBlush); } } + public static XLColor LavenderBlush => FromColor(SKColors.LavenderBlush); - public static XLColor LawnGreen { get { return FromColor(Color.LawnGreen); } } + public static XLColor LawnGreen => FromColor(SKColors.LawnGreen); - public static XLColor LemonChiffon { get { return FromColor(Color.LemonChiffon); } } + public static XLColor LemonChiffon => FromColor(SKColors.LemonChiffon); - public static XLColor LightBlue { get { return FromColor(Color.LightBlue); } } + public static XLColor LightBlue => FromColor(SKColors.LightBlue); - public static XLColor LightCoral { get { return FromColor(Color.LightCoral); } } + public static XLColor LightCoral => FromColor(SKColors.LightCoral); - public static XLColor LightCyan { get { return FromColor(Color.LightCyan); } } + public static XLColor LightCyan => FromColor(SKColors.LightCyan); - public static XLColor LightGoldenrodYellow { get { return FromColor(Color.LightGoldenrodYellow); } } + public static XLColor LightGoldenrodYellow => FromColor(SKColors.LightGoldenrodYellow); - public static XLColor LightGray { get { return FromColor(Color.LightGray); } } + public static XLColor LightGray => FromColor(SKColors.LightGray); - public static XLColor LightGreen { get { return FromColor(Color.LightGreen); } } + public static XLColor LightGreen => FromColor(SKColors.LightGreen); - public static XLColor LightPink { get { return FromColor(Color.LightPink); } } + public static XLColor LightPink => FromColor(SKColors.LightPink); - public static XLColor LightSalmon { get { return FromColor(Color.LightSalmon); } } + public static XLColor LightSalmon => FromColor(SKColors.LightSalmon); - public static XLColor LightSeaGreen { get { return FromColor(Color.LightSeaGreen); } } + public static XLColor LightSeaGreen => FromColor(SKColors.LightSeaGreen); - public static XLColor LightSkyBlue { get { return FromColor(Color.LightSkyBlue); } } + public static XLColor LightSkyBlue => FromColor(SKColors.LightSkyBlue); - public static XLColor LightSlateGray { get { return FromColor(Color.LightSlateGray); } } + public static XLColor LightSlateGray => FromColor(SKColors.LightSlateGray); - public static XLColor LightSteelBlue { get { return FromColor(Color.LightSteelBlue); } } + public static XLColor LightSteelBlue => FromColor(SKColors.LightSteelBlue); - public static XLColor LightYellow { get { return FromColor(Color.LightYellow); } } + public static XLColor LightYellow => FromColor(SKColors.LightYellow); - public static XLColor Lime { get { return FromColor(Color.Lime); } } + public static XLColor Lime => FromColor(SKColors.Lime); - public static XLColor LimeGreen { get { return FromColor(Color.LimeGreen); } } + public static XLColor LimeGreen => FromColor(SKColors.LimeGreen); - public static XLColor Linen { get { return FromColor(Color.Linen); } } + public static XLColor Linen => FromColor(SKColors.Linen); - public static XLColor Magenta { get { return FromColor(Color.Magenta); } } + public static XLColor Magenta => FromColor(SKColors.Magenta); - public static XLColor Maroon { get { return FromColor(Color.Maroon); } } + public static XLColor Maroon => FromColor(SKColors.Maroon); - public static XLColor MediumAquamarine { get { return FromColor(Color.MediumAquamarine); } } + public static XLColor MediumAquamarine => FromColor(SKColors.MediumAquamarine); - public static XLColor MediumBlue { get { return FromColor(Color.MediumBlue); } } + public static XLColor MediumBlue => FromColor(SKColors.MediumBlue); - public static XLColor MediumOrchid { get { return FromColor(Color.MediumOrchid); } } + public static XLColor MediumOrchid => FromColor(SKColors.MediumOrchid); - public static XLColor MediumPurple { get { return FromColor(Color.MediumPurple); } } + public static XLColor MediumPurple => FromColor(SKColors.MediumPurple); - public static XLColor MediumSeaGreen { get { return FromColor(Color.MediumSeaGreen); } } + public static XLColor MediumSeaGreen => FromColor(SKColors.MediumSeaGreen); - public static XLColor MediumSlateBlue { get { return FromColor(Color.MediumSlateBlue); } } + public static XLColor MediumSlateBlue => FromColor(SKColors.MediumSlateBlue); - public static XLColor MediumSpringGreen { get { return FromColor(Color.MediumSpringGreen); } } + public static XLColor MediumSpringGreen => FromColor(SKColors.MediumSpringGreen); - public static XLColor MediumTurquoise { get { return FromColor(Color.MediumTurquoise); } } + public static XLColor MediumTurquoise => FromColor(SKColors.MediumTurquoise); - public static XLColor MediumVioletRed { get { return FromColor(Color.MediumVioletRed); } } + public static XLColor MediumVioletRed => FromColor(SKColors.MediumVioletRed); - public static XLColor MidnightBlue { get { return FromColor(Color.MidnightBlue); } } + public static XLColor MidnightBlue => FromColor(SKColors.MidnightBlue); - public static XLColor MintCream { get { return FromColor(Color.MintCream); } } + public static XLColor MintCream => FromColor(SKColors.MintCream); - public static XLColor MistyRose { get { return FromColor(Color.MistyRose); } } + public static XLColor MistyRose => FromColor(SKColors.MistyRose); - public static XLColor Moccasin { get { return FromColor(Color.Moccasin); } } + public static XLColor Moccasin => FromColor(SKColors.Moccasin); - public static XLColor NavajoWhite { get { return FromColor(Color.NavajoWhite); } } + public static XLColor NavajoWhite => FromColor(SKColors.NavajoWhite); - public static XLColor Navy { get { return FromColor(Color.Navy); } } + public static XLColor Navy => FromColor(SKColors.Navy); - public static XLColor OldLace { get { return FromColor(Color.OldLace); } } + public static XLColor OldLace => FromColor(SKColors.OldLace); - public static XLColor Olive { get { return FromColor(Color.Olive); } } + public static XLColor Olive => FromColor(SKColors.Olive); - public static XLColor OliveDrab { get { return FromColor(Color.OliveDrab); } } + public static XLColor OliveDrab => FromColor(SKColors.OliveDrab); - public static XLColor Orange { get { return FromColor(Color.Orange); } } + public static XLColor Orange => FromColor(SKColors.Orange); - public static XLColor OrangeRed { get { return FromColor(Color.OrangeRed); } } + public static XLColor OrangeRed => FromColor(SKColors.OrangeRed); - public static XLColor Orchid { get { return FromColor(Color.Orchid); } } + public static XLColor Orchid => FromColor(SKColors.Orchid); - public static XLColor PaleGoldenrod { get { return FromColor(Color.PaleGoldenrod); } } + public static XLColor PaleGoldenrod => FromColor(SKColors.PaleGoldenrod); - public static XLColor PaleGreen { get { return FromColor(Color.PaleGreen); } } + public static XLColor PaleGreen => FromColor(SKColors.PaleGreen); - public static XLColor PaleTurquoise { get { return FromColor(Color.PaleTurquoise); } } + public static XLColor PaleTurquoise => FromColor(SKColors.PaleTurquoise); - public static XLColor PaleVioletRed { get { return FromColor(Color.PaleVioletRed); } } + public static XLColor PaleVioletRed => FromColor(SKColors.PaleVioletRed); - public static XLColor PapayaWhip { get { return FromColor(Color.PapayaWhip); } } + public static XLColor PapayaWhip => FromColor(SKColors.PapayaWhip); - public static XLColor PeachPuff { get { return FromColor(Color.PeachPuff); } } + public static XLColor PeachPuff => FromColor(SKColors.PeachPuff); - public static XLColor Peru { get { return FromColor(Color.Peru); } } + public static XLColor Peru => FromColor(SKColors.Peru); - public static XLColor Pink { get { return FromColor(Color.Pink); } } + public static XLColor Pink => FromColor(SKColors.Pink); - public static XLColor Plum { get { return FromColor(Color.Plum); } } + public static XLColor Plum => FromColor(SKColors.Plum); - public static XLColor PowderBlue { get { return FromColor(Color.PowderBlue); } } + public static XLColor PowderBlue => FromColor(SKColors.PowderBlue); - public static XLColor Purple { get { return FromColor(Color.Purple); } } + public static XLColor Purple => FromColor(SKColors.Purple); - public static XLColor Red { get { return FromColor(Color.Red); } } + public static XLColor Red => FromColor(SKColors.Red); - public static XLColor RosyBrown { get { return FromColor(Color.RosyBrown); } } + public static XLColor RosyBrown => FromColor(SKColors.RosyBrown); - public static XLColor RoyalBlue { get { return FromColor(Color.RoyalBlue); } } + public static XLColor RoyalBlue => FromColor(SKColors.RoyalBlue); - public static XLColor SaddleBrown { get { return FromColor(Color.SaddleBrown); } } + public static XLColor SaddleBrown => FromColor(SKColors.SaddleBrown); - public static XLColor Salmon { get { return FromColor(Color.Salmon); } } + public static XLColor Salmon => FromColor(SKColors.Salmon); - public static XLColor SandyBrown { get { return FromColor(Color.SandyBrown); } } + public static XLColor SandyBrown => FromColor(SKColors.SandyBrown); - public static XLColor SeaGreen { get { return FromColor(Color.SeaGreen); } } + public static XLColor SeaGreen => FromColor(SKColors.SeaGreen); - public static XLColor SeaShell { get { return FromColor(Color.SeaShell); } } + public static XLColor SeaShell => FromColor(SKColors.SeaShell); - public static XLColor Sienna { get { return FromColor(Color.Sienna); } } + public static XLColor Sienna => FromColor(SKColors.Sienna); - public static XLColor Silver { get { return FromColor(Color.Silver); } } + public static XLColor Silver => FromColor(SKColors.Silver); - public static XLColor SkyBlue { get { return FromColor(Color.SkyBlue); } } + public static XLColor SkyBlue => FromColor(SKColors.SkyBlue); - public static XLColor SlateBlue { get { return FromColor(Color.SlateBlue); } } + public static XLColor SlateBlue => FromColor(SKColors.SlateBlue); - public static XLColor SlateGray { get { return FromColor(Color.SlateGray); } } + public static XLColor SlateGray => FromColor(SKColors.SlateGray); - public static XLColor Snow { get { return FromColor(Color.Snow); } } + public static XLColor Snow => FromColor(SKColors.Snow); - public static XLColor SpringGreen { get { return FromColor(Color.SpringGreen); } } + public static XLColor SpringGreen => FromColor(SKColors.SpringGreen); - public static XLColor SteelBlue { get { return FromColor(Color.SteelBlue); } } + public static XLColor SteelBlue => FromColor(SKColors.SteelBlue); - public static XLColor Tan { get { return FromColor(Color.Tan); } } + public static XLColor Tan => FromColor(SKColors.Tan); - public static XLColor Teal { get { return FromColor(Color.Teal); } } + public static XLColor Teal => FromColor(SKColors.Teal); - public static XLColor Thistle { get { return FromColor(Color.Thistle); } } + public static XLColor Thistle => FromColor(SKColors.Thistle); - public static XLColor Tomato { get { return FromColor(Color.Tomato); } } + public static XLColor Tomato => FromColor(SKColors.Tomato); - public static XLColor Turquoise { get { return FromColor(Color.Turquoise); } } + public static XLColor Turquoise => FromColor(SKColors.Turquoise); - public static XLColor Violet { get { return FromColor(Color.Violet); } } + public static XLColor Violet => FromColor(SKColors.Violet); - public static XLColor Wheat { get { return FromColor(Color.Wheat); } } + public static XLColor Wheat => FromColor(SKColors.Wheat); - public static XLColor White { get { return FromColor(Color.White); } } + public static XLColor White => FromColor(SKColors.White); - public static XLColor WhiteSmoke { get { return FromColor(Color.WhiteSmoke); } } + public static XLColor WhiteSmoke => FromColor(SKColors.WhiteSmoke); - public static XLColor Yellow { get { return FromColor(Color.Yellow); } } + public static XLColor Yellow => FromColor(SKColors.Yellow); - public static XLColor YellowGreen { get { return FromColor(Color.YellowGreen); } } + public static XLColor YellowGreen => FromColor(SKColors.YellowGreen); - public static XLColor AirForceBlue { get { return FromHtml("#FF5D8AA8"); } } + public static XLColor AirForceBlue => FromHtml("#FF5D8AA8"); - public static XLColor Alizarin { get { return FromHtml("#FFE32636"); } } + public static XLColor Alizarin => FromHtml("#FFE32636"); - public static XLColor Almond { get { return FromHtml("#FFEFDECD"); } } + public static XLColor Almond => FromHtml("#FFEFDECD"); - public static XLColor Amaranth { get { return FromHtml("#FFE52B50"); } } + public static XLColor Amaranth => FromHtml("#FFE52B50"); - public static XLColor Amber { get { return FromHtml("#FFFFBF00"); } } + public static XLColor Amber => FromHtml("#FFFFBF00"); - public static XLColor AmberSaeEce { get { return FromHtml("#FFFF7E00"); } } + public static XLColor AmberSaeEce => FromHtml("#FFFF7E00"); - public static XLColor AmericanRose { get { return FromHtml("#FFFF033E"); } } + public static XLColor AmericanRose => FromHtml("#FFFF033E"); - public static XLColor Amethyst { get { return FromHtml("#FF9966CC"); } } + public static XLColor Amethyst => FromHtml("#FF9966CC"); - public static XLColor AntiFlashWhite { get { return FromHtml("#FFF2F3F4"); } } + public static XLColor AntiFlashWhite => FromHtml("#FFF2F3F4"); - public static XLColor AntiqueBrass { get { return FromHtml("#FFCD9575"); } } + public static XLColor AntiqueBrass => FromHtml("#FFCD9575"); - public static XLColor AntiqueFuchsia { get { return FromHtml("#FF915C83"); } } + public static XLColor AntiqueFuchsia => FromHtml("#FF915C83"); - public static XLColor AppleGreen { get { return FromHtml("#FF8DB600"); } } + public static XLColor AppleGreen => FromHtml("#FF8DB600"); - public static XLColor Apricot { get { return FromHtml("#FFFBCEB1"); } } + public static XLColor Apricot => FromHtml("#FFFBCEB1"); - public static XLColor Aquamarine1 { get { return FromHtml("#FF7FFFD0"); } } + public static XLColor Aquamarine1 => FromHtml("#FF7FFFD0"); - public static XLColor ArmyGreen { get { return FromHtml("#FF4B5320"); } } + public static XLColor ArmyGreen => FromHtml("#FF4B5320"); - public static XLColor Arsenic { get { return FromHtml("#FF3B444B"); } } + public static XLColor Arsenic => FromHtml("#FF3B444B"); - public static XLColor ArylideYellow { get { return FromHtml("#FFE9D66B"); } } + public static XLColor ArylideYellow => FromHtml("#FFE9D66B"); - public static XLColor AshGrey { get { return FromHtml("#FFB2BEB5"); } } + public static XLColor AshGrey => FromHtml("#FFB2BEB5"); - public static XLColor Asparagus { get { return FromHtml("#FF87A96B"); } } + public static XLColor Asparagus => FromHtml("#FF87A96B"); - public static XLColor AtomicTangerine { get { return FromHtml("#FFFF9966"); } } + public static XLColor AtomicTangerine => FromHtml("#FFFF9966"); - public static XLColor Auburn { get { return FromHtml("#FF6D351A"); } } + public static XLColor Auburn => FromHtml("#FF6D351A"); - public static XLColor Aureolin { get { return FromHtml("#FFFDEE00"); } } + public static XLColor Aureolin => FromHtml("#FFFDEE00"); - public static XLColor Aurometalsaurus { get { return FromHtml("#FF6E7F80"); } } + public static XLColor Aurometalsaurus => FromHtml("#FF6E7F80"); - public static XLColor Awesome { get { return FromHtml("#FFFF2052"); } } + public static XLColor Awesome => FromHtml("#FFFF2052"); - public static XLColor AzureColorWheel { get { return FromHtml("#FF007FFF"); } } + public static XLColor AzureColorWheel => FromHtml("#FF007FFF"); - public static XLColor BabyBlue { get { return FromHtml("#FF89CFF0"); } } + public static XLColor BabyBlue => FromHtml("#FF89CFF0"); - public static XLColor BabyBlueEyes { get { return FromHtml("#FFA1CAF1"); } } + public static XLColor BabyBlueEyes => FromHtml("#FFA1CAF1"); - public static XLColor BabyPink { get { return FromHtml("#FFF4C2C2"); } } + public static XLColor BabyPink => FromHtml("#FFF4C2C2"); - public static XLColor BallBlue { get { return FromHtml("#FF21ABCD"); } } + public static XLColor BallBlue => FromHtml("#FF21ABCD"); - public static XLColor BananaMania { get { return FromHtml("#FFFAE7B5"); } } + public static XLColor BananaMania => FromHtml("#FFFAE7B5"); - public static XLColor BattleshipGrey { get { return FromHtml("#FF848482"); } } + public static XLColor BattleshipGrey => FromHtml("#FF848482"); - public static XLColor Bazaar { get { return FromHtml("#FF98777B"); } } + public static XLColor Bazaar => FromHtml("#FF98777B"); - public static XLColor BeauBlue { get { return FromHtml("#FFBCD4E6"); } } + public static XLColor BeauBlue => FromHtml("#FFBCD4E6"); - public static XLColor Beaver { get { return FromHtml("#FF9F8170"); } } + public static XLColor Beaver => FromHtml("#FF9F8170"); - public static XLColor Bistre { get { return FromHtml("#FF3D2B1F"); } } + public static XLColor Bistre => FromHtml("#FF3D2B1F"); - public static XLColor Bittersweet { get { return FromHtml("#FFFE6F5E"); } } + public static XLColor Bittersweet => FromHtml("#FFFE6F5E"); - public static XLColor BleuDeFrance { get { return FromHtml("#FF318CE7"); } } + public static XLColor BleuDeFrance => FromHtml("#FF318CE7"); - public static XLColor BlizzardBlue { get { return FromHtml("#FFACE5EE"); } } + public static XLColor BlizzardBlue => FromHtml("#FFACE5EE"); - public static XLColor Blond { get { return FromHtml("#FFFAF0BE"); } } + public static XLColor Blond => FromHtml("#FFFAF0BE"); - public static XLColor BlueBell { get { return FromHtml("#FFA2A2D0"); } } + public static XLColor BlueBell => FromHtml("#FFA2A2D0"); - public static XLColor BlueGray { get { return FromHtml("#FF6699CC"); } } + public static XLColor BlueGray => FromHtml("#FF6699CC"); - public static XLColor BlueGreen { get { return FromHtml("#FF00DDDD"); } } + public static XLColor BlueGreen => FromHtml("#FF00DDDD"); - public static XLColor BluePigment { get { return FromHtml("#FF333399"); } } + public static XLColor BluePigment => FromHtml("#FF333399"); - public static XLColor BlueRyb { get { return FromHtml("#FF0247FE"); } } + public static XLColor BlueRyb => FromHtml("#FF0247FE"); - public static XLColor Blush { get { return FromHtml("#FFDE5D83"); } } + public static XLColor Blush => FromHtml("#FFDE5D83"); - public static XLColor Bole { get { return FromHtml("#FF79443B"); } } + public static XLColor Bole => FromHtml("#FF79443B"); - public static XLColor BondiBlue { get { return FromHtml("#FF0095B6"); } } + public static XLColor BondiBlue => FromHtml("#FF0095B6"); - public static XLColor BostonUniversityRed { get { return FromHtml("#FFCC0000"); } } + public static XLColor BostonUniversityRed => FromHtml("#FFCC0000"); - public static XLColor BrandeisBlue { get { return FromHtml("#FF0070FF"); } } + public static XLColor BrandeisBlue => FromHtml("#FF0070FF"); - public static XLColor Brass { get { return FromHtml("#FFB5A642"); } } + public static XLColor Brass => FromHtml("#FFB5A642"); - public static XLColor BrickRed { get { return FromHtml("#FFCB4154"); } } + public static XLColor BrickRed => FromHtml("#FFCB4154"); - public static XLColor BrightCerulean { get { return FromHtml("#FF1DACD6"); } } + public static XLColor BrightCerulean => FromHtml("#FF1DACD6"); - public static XLColor BrightGreen { get { return FromHtml("#FF66FF00"); } } + public static XLColor BrightGreen => FromHtml("#FF66FF00"); - public static XLColor BrightLavender { get { return FromHtml("#FFBF94E4"); } } + public static XLColor BrightLavender => FromHtml("#FFBF94E4"); - public static XLColor BrightMaroon { get { return FromHtml("#FFC32148"); } } + public static XLColor BrightMaroon => FromHtml("#FFC32148"); - public static XLColor BrightPink { get { return FromHtml("#FFFF007F"); } } + public static XLColor BrightPink => FromHtml("#FFFF007F"); - public static XLColor BrightTurquoise { get { return FromHtml("#FF08E8DE"); } } + public static XLColor BrightTurquoise => FromHtml("#FF08E8DE"); - public static XLColor BrightUbe { get { return FromHtml("#FFD19FE8"); } } + public static XLColor BrightUbe => FromHtml("#FFD19FE8"); - public static XLColor BrilliantLavender { get { return FromHtml("#FFF4BBFF"); } } + public static XLColor BrilliantLavender => FromHtml("#FFF4BBFF"); - public static XLColor BrilliantRose { get { return FromHtml("#FFFF55A3"); } } + public static XLColor BrilliantRose => FromHtml("#FFFF55A3"); - public static XLColor BrinkPink { get { return FromHtml("#FFFB607F"); } } + public static XLColor BrinkPink => FromHtml("#FFFB607F"); - public static XLColor BritishRacingGreen { get { return FromHtml("#FF004225"); } } + public static XLColor BritishRacingGreen => FromHtml("#FF004225"); - public static XLColor Bronze { get { return FromHtml("#FFCD7F32"); } } + public static XLColor Bronze => FromHtml("#FFCD7F32"); - public static XLColor BrownTraditional { get { return FromHtml("#FF964B00"); } } + public static XLColor BrownTraditional => FromHtml("#FF964B00"); - public static XLColor BubbleGum { get { return FromHtml("#FFFFC1CC"); } } + public static XLColor BubbleGum => FromHtml("#FFFFC1CC"); - public static XLColor Bubbles { get { return FromHtml("#FFE7FEFF"); } } + public static XLColor Bubbles => FromHtml("#FFE7FEFF"); - public static XLColor Buff { get { return FromHtml("#FFF0DC82"); } } + public static XLColor Buff => FromHtml("#FFF0DC82"); - public static XLColor BulgarianRose { get { return FromHtml("#FF480607"); } } + public static XLColor BulgarianRose => FromHtml("#FF480607"); - public static XLColor Burgundy { get { return FromHtml("#FF800020"); } } + public static XLColor Burgundy => FromHtml("#FF800020"); - public static XLColor BurntOrange { get { return FromHtml("#FFCC5500"); } } + public static XLColor BurntOrange => FromHtml("#FFCC5500"); - public static XLColor BurntSienna { get { return FromHtml("#FFE97451"); } } + public static XLColor BurntSienna => FromHtml("#FFE97451"); - public static XLColor BurntUmber { get { return FromHtml("#FF8A3324"); } } + public static XLColor BurntUmber => FromHtml("#FF8A3324"); - public static XLColor Byzantine { get { return FromHtml("#FFBD33A4"); } } + public static XLColor Byzantine => FromHtml("#FFBD33A4"); - public static XLColor Byzantium { get { return FromHtml("#FF702963"); } } + public static XLColor Byzantium => FromHtml("#FF702963"); - public static XLColor Cadet { get { return FromHtml("#FF536872"); } } + public static XLColor Cadet => FromHtml("#FF536872"); - public static XLColor CadetGrey { get { return FromHtml("#FF91A3B0"); } } + public static XLColor CadetGrey => FromHtml("#FF91A3B0"); - public static XLColor CadmiumGreen { get { return FromHtml("#FF006B3C"); } } + public static XLColor CadmiumGreen => FromHtml("#FF006B3C"); - public static XLColor CadmiumOrange { get { return FromHtml("#FFED872D"); } } + public static XLColor CadmiumOrange => FromHtml("#FFED872D"); - public static XLColor CadmiumRed { get { return FromHtml("#FFE30022"); } } + public static XLColor CadmiumRed => FromHtml("#FFE30022"); - public static XLColor CadmiumYellow { get { return FromHtml("#FFFFF600"); } } + public static XLColor CadmiumYellow => FromHtml("#FFFFF600"); - public static XLColor CalPolyPomonaGreen { get { return FromHtml("#FF1E4D2B"); } } + public static XLColor CalPolyPomonaGreen => FromHtml("#FF1E4D2B"); - public static XLColor CambridgeBlue { get { return FromHtml("#FFA3C1AD"); } } + public static XLColor CambridgeBlue => FromHtml("#FFA3C1AD"); - public static XLColor Camel { get { return FromHtml("#FFC19A6B"); } } + public static XLColor Camel => FromHtml("#FFC19A6B"); - public static XLColor CamouflageGreen { get { return FromHtml("#FF78866B"); } } + public static XLColor CamouflageGreen => FromHtml("#FF78866B"); - public static XLColor CanaryYellow { get { return FromHtml("#FFFFEF00"); } } + public static XLColor CanaryYellow => FromHtml("#FFFFEF00"); - public static XLColor CandyAppleRed { get { return FromHtml("#FFFF0800"); } } + public static XLColor CandyAppleRed => FromHtml("#FFFF0800"); - public static XLColor CandyPink { get { return FromHtml("#FFE4717A"); } } + public static XLColor CandyPink => FromHtml("#FFE4717A"); - public static XLColor CaputMortuum { get { return FromHtml("#FF592720"); } } + public static XLColor CaputMortuum => FromHtml("#FF592720"); - public static XLColor Cardinal { get { return FromHtml("#FFC41E3A"); } } + public static XLColor Cardinal => FromHtml("#FFC41E3A"); - public static XLColor CaribbeanGreen { get { return FromHtml("#FF00CC99"); } } + public static XLColor CaribbeanGreen => FromHtml("#FF00CC99"); - public static XLColor Carmine { get { return FromHtml("#FF960018"); } } + public static XLColor Carmine => FromHtml("#FF960018"); - public static XLColor CarminePink { get { return FromHtml("#FFEB4C42"); } } + public static XLColor CarminePink => FromHtml("#FFEB4C42"); - public static XLColor CarmineRed { get { return FromHtml("#FFFF0038"); } } + public static XLColor CarmineRed => FromHtml("#FFFF0038"); - public static XLColor CarnationPink { get { return FromHtml("#FFFFA6C9"); } } + public static XLColor CarnationPink => FromHtml("#FFFFA6C9"); - public static XLColor Carnelian { get { return FromHtml("#FFB31B1B"); } } + public static XLColor Carnelian => FromHtml("#FFB31B1B"); - public static XLColor CarolinaBlue { get { return FromHtml("#FF99BADD"); } } + public static XLColor CarolinaBlue => FromHtml("#FF99BADD"); - public static XLColor CarrotOrange { get { return FromHtml("#FFED9121"); } } + public static XLColor CarrotOrange => FromHtml("#FFED9121"); - public static XLColor Ceil { get { return FromHtml("#FF92A1CF"); } } + public static XLColor Ceil => FromHtml("#FF92A1CF"); - public static XLColor Celadon { get { return FromHtml("#FFACE1AF"); } } + public static XLColor Celadon => FromHtml("#FFACE1AF"); - public static XLColor CelestialBlue { get { return FromHtml("#FF4997D0"); } } + public static XLColor CelestialBlue => FromHtml("#FF4997D0"); - public static XLColor Cerise { get { return FromHtml("#FFDE3163"); } } + public static XLColor Cerise => FromHtml("#FFDE3163"); - public static XLColor CerisePink { get { return FromHtml("#FFEC3B83"); } } + public static XLColor CerisePink => FromHtml("#FFEC3B83"); - public static XLColor Cerulean { get { return FromHtml("#FF007BA7"); } } + public static XLColor Cerulean => FromHtml("#FF007BA7"); - public static XLColor CeruleanBlue { get { return FromHtml("#FF2A52BE"); } } + public static XLColor CeruleanBlue => FromHtml("#FF2A52BE"); - public static XLColor Chamoisee { get { return FromHtml("#FFA0785A"); } } + public static XLColor Chamoisee => FromHtml("#FFA0785A"); - public static XLColor Champagne { get { return FromHtml("#FFF7E7CE"); } } + public static XLColor Champagne => FromHtml("#FFF7E7CE"); - public static XLColor Charcoal { get { return FromHtml("#FF36454F"); } } + public static XLColor Charcoal => FromHtml("#FF36454F"); - public static XLColor ChartreuseTraditional { get { return FromHtml("#FFDFFF00"); } } + public static XLColor ChartreuseTraditional => FromHtml("#FFDFFF00"); - public static XLColor CherryBlossomPink { get { return FromHtml("#FFFFB7C5"); } } + public static XLColor CherryBlossomPink => FromHtml("#FFFFB7C5"); - public static XLColor Chocolate1 { get { return FromHtml("#FF7B3F00"); } } + public static XLColor Chocolate1 => FromHtml("#FF7B3F00"); - public static XLColor ChromeYellow { get { return FromHtml("#FFFFA700"); } } + public static XLColor ChromeYellow => FromHtml("#FFFFA700"); - public static XLColor Cinereous { get { return FromHtml("#FF98817B"); } } + public static XLColor Cinereous => FromHtml("#FF98817B"); - public static XLColor Cinnabar { get { return FromHtml("#FFE34234"); } } + public static XLColor Cinnabar => FromHtml("#FFE34234"); - public static XLColor Citrine { get { return FromHtml("#FFE4D00A"); } } + public static XLColor Citrine => FromHtml("#FFE4D00A"); - public static XLColor ClassicRose { get { return FromHtml("#FFFBCCE7"); } } + public static XLColor ClassicRose => FromHtml("#FFFBCCE7"); - public static XLColor Cobalt { get { return FromHtml("#FF0047AB"); } } + public static XLColor Cobalt => FromHtml("#FF0047AB"); - public static XLColor ColumbiaBlue { get { return FromHtml("#FF9BDDFF"); } } + public static XLColor ColumbiaBlue => FromHtml("#FF9BDDFF"); - public static XLColor CoolBlack { get { return FromHtml("#FF002E63"); } } + public static XLColor CoolBlack => FromHtml("#FF002E63"); - public static XLColor CoolGrey { get { return FromHtml("#FF8C92AC"); } } + public static XLColor CoolGrey => FromHtml("#FF8C92AC"); - public static XLColor Copper { get { return FromHtml("#FFB87333"); } } + public static XLColor Copper => FromHtml("#FFB87333"); - public static XLColor CopperRose { get { return FromHtml("#FF996666"); } } + public static XLColor CopperRose => FromHtml("#FF996666"); - public static XLColor Coquelicot { get { return FromHtml("#FFFF3800"); } } + public static XLColor Coquelicot => FromHtml("#FFFF3800"); - public static XLColor CoralPink { get { return FromHtml("#FFF88379"); } } + public static XLColor CoralPink => FromHtml("#FFF88379"); - public static XLColor CoralRed { get { return FromHtml("#FFFF4040"); } } + public static XLColor CoralRed => FromHtml("#FFFF4040"); - public static XLColor Cordovan { get { return FromHtml("#FF893F45"); } } + public static XLColor Cordovan => FromHtml("#FF893F45"); - public static XLColor Corn { get { return FromHtml("#FFFBEC5D"); } } + public static XLColor Corn => FromHtml("#FFFBEC5D"); - public static XLColor CornellRed { get { return FromHtml("#FFB31B1B"); } } + public static XLColor CornellRed => FromHtml("#FFB31B1B"); - public static XLColor CosmicLatte { get { return FromHtml("#FFFFF8E7"); } } + public static XLColor CosmicLatte => FromHtml("#FFFFF8E7"); - public static XLColor CottonCandy { get { return FromHtml("#FFFFBCD9"); } } + public static XLColor CottonCandy => FromHtml("#FFFFBCD9"); - public static XLColor Cream { get { return FromHtml("#FFFFFDD0"); } } + public static XLColor Cream => FromHtml("#FFFFFDD0"); - public static XLColor CrimsonGlory { get { return FromHtml("#FFBE0032"); } } + public static XLColor CrimsonGlory => FromHtml("#FFBE0032"); - public static XLColor CyanProcess { get { return FromHtml("#FF00B7EB"); } } + public static XLColor CyanProcess => FromHtml("#FF00B7EB"); - public static XLColor Daffodil { get { return FromHtml("#FFFFFF31"); } } + public static XLColor Daffodil => FromHtml("#FFFFFF31"); - public static XLColor Dandelion { get { return FromHtml("#FFF0E130"); } } + public static XLColor Dandelion => FromHtml("#FFF0E130"); - public static XLColor DarkBrown { get { return FromHtml("#FF654321"); } } + public static XLColor DarkBrown => FromHtml("#FF654321"); - public static XLColor DarkByzantium { get { return FromHtml("#FF5D3954"); } } + public static XLColor DarkByzantium => FromHtml("#FF5D3954"); - public static XLColor DarkCandyAppleRed { get { return FromHtml("#FFA40000"); } } + public static XLColor DarkCandyAppleRed => FromHtml("#FFA40000"); - public static XLColor DarkCerulean { get { return FromHtml("#FF08457E"); } } + public static XLColor DarkCerulean => FromHtml("#FF08457E"); - public static XLColor DarkChampagne { get { return FromHtml("#FFC2B280"); } } + public static XLColor DarkChampagne => FromHtml("#FFC2B280"); - public static XLColor DarkChestnut { get { return FromHtml("#FF986960"); } } + public static XLColor DarkChestnut => FromHtml("#FF986960"); - public static XLColor DarkCoral { get { return FromHtml("#FFCD5B45"); } } + public static XLColor DarkCoral => FromHtml("#FFCD5B45"); - public static XLColor DarkElectricBlue { get { return FromHtml("#FF536878"); } } + public static XLColor DarkElectricBlue => FromHtml("#FF536878"); - public static XLColor DarkGreen1 { get { return FromHtml("#FF013220"); } } + public static XLColor DarkGreen1 => FromHtml("#FF013220"); - public static XLColor DarkJungleGreen { get { return FromHtml("#FF1A2421"); } } + public static XLColor DarkJungleGreen => FromHtml("#FF1A2421"); - public static XLColor DarkLava { get { return FromHtml("#FF483C32"); } } + public static XLColor DarkLava => FromHtml("#FF483C32"); - public static XLColor DarkLavender { get { return FromHtml("#FF734F96"); } } + public static XLColor DarkLavender => FromHtml("#FF734F96"); - public static XLColor DarkMidnightBlue { get { return FromHtml("#FF003366"); } } + public static XLColor DarkMidnightBlue => FromHtml("#FF003366"); - public static XLColor DarkPastelBlue { get { return FromHtml("#FF779ECB"); } } + public static XLColor DarkPastelBlue => FromHtml("#FF779ECB"); - public static XLColor DarkPastelGreen { get { return FromHtml("#FF03C03C"); } } + public static XLColor DarkPastelGreen => FromHtml("#FF03C03C"); - public static XLColor DarkPastelPurple { get { return FromHtml("#FF966FD6"); } } + public static XLColor DarkPastelPurple => FromHtml("#FF966FD6"); - public static XLColor DarkPastelRed { get { return FromHtml("#FFC23B22"); } } + public static XLColor DarkPastelRed => FromHtml("#FFC23B22"); - public static XLColor DarkPink { get { return FromHtml("#FFE75480"); } } + public static XLColor DarkPink => FromHtml("#FFE75480"); - public static XLColor DarkPowderBlue { get { return FromHtml("#FF003399"); } } + public static XLColor DarkPowderBlue => FromHtml("#FF003399"); - public static XLColor DarkRaspberry { get { return FromHtml("#FF872657"); } } + public static XLColor DarkRaspberry => FromHtml("#FF872657"); - public static XLColor DarkScarlet { get { return FromHtml("#FF560319"); } } + public static XLColor DarkScarlet => FromHtml("#FF560319"); - public static XLColor DarkSienna { get { return FromHtml("#FF3C1414"); } } + public static XLColor DarkSienna => FromHtml("#FF3C1414"); - public static XLColor DarkSpringGreen { get { return FromHtml("#FF177245"); } } + public static XLColor DarkSpringGreen => FromHtml("#FF177245"); - public static XLColor DarkTan { get { return FromHtml("#FF918151"); } } + public static XLColor DarkTan => FromHtml("#FF918151"); - public static XLColor DarkTangerine { get { return FromHtml("#FFFFA812"); } } + public static XLColor DarkTangerine => FromHtml("#FFFFA812"); - public static XLColor DarkTaupe { get { return FromHtml("#FF483C32"); } } + public static XLColor DarkTaupe => FromHtml("#FF483C32"); - public static XLColor DarkTerraCotta { get { return FromHtml("#FFCC4E5C"); } } + public static XLColor DarkTerraCotta => FromHtml("#FFCC4E5C"); - public static XLColor DartmouthGreen { get { return FromHtml("#FF00693E"); } } + public static XLColor DartmouthGreen => FromHtml("#FF00693E"); - public static XLColor DavysGrey { get { return FromHtml("#FF555555"); } } + public static XLColor DavysGrey => FromHtml("#FF555555"); - public static XLColor DebianRed { get { return FromHtml("#FFD70A53"); } } + public static XLColor DebianRed => FromHtml("#FFD70A53"); - public static XLColor DeepCarmine { get { return FromHtml("#FFA9203E"); } } + public static XLColor DeepCarmine => FromHtml("#FFA9203E"); - public static XLColor DeepCarminePink { get { return FromHtml("#FFEF3038"); } } + public static XLColor DeepCarminePink => FromHtml("#FFEF3038"); - public static XLColor DeepCarrotOrange { get { return FromHtml("#FFE9692C"); } } + public static XLColor DeepCarrotOrange => FromHtml("#FFE9692C"); - public static XLColor DeepCerise { get { return FromHtml("#FFDA3287"); } } + public static XLColor DeepCerise => FromHtml("#FFDA3287"); - public static XLColor DeepChampagne { get { return FromHtml("#FFFAD6A5"); } } + public static XLColor DeepChampagne => FromHtml("#FFFAD6A5"); - public static XLColor DeepChestnut { get { return FromHtml("#FFB94E48"); } } + public static XLColor DeepChestnut => FromHtml("#FFB94E48"); - public static XLColor DeepFuchsia { get { return FromHtml("#FFC154C1"); } } + public static XLColor DeepFuchsia => FromHtml("#FFC154C1"); - public static XLColor DeepJungleGreen { get { return FromHtml("#FF004B49"); } } + public static XLColor DeepJungleGreen => FromHtml("#FF004B49"); - public static XLColor DeepLilac { get { return FromHtml("#FF9955BB"); } } + public static XLColor DeepLilac => FromHtml("#FF9955BB"); - public static XLColor DeepMagenta { get { return FromHtml("#FFCC00CC"); } } + public static XLColor DeepMagenta => FromHtml("#FFCC00CC"); - public static XLColor DeepPeach { get { return FromHtml("#FFFFCBA4"); } } + public static XLColor DeepPeach => FromHtml("#FFFFCBA4"); - public static XLColor DeepSaffron { get { return FromHtml("#FFFF9933"); } } + public static XLColor DeepSaffron => FromHtml("#FFFF9933"); - public static XLColor Denim { get { return FromHtml("#FF1560BD"); } } + public static XLColor Denim => FromHtml("#FF1560BD"); - public static XLColor Desert { get { return FromHtml("#FFC19A6B"); } } + public static XLColor Desert => FromHtml("#FFC19A6B"); - public static XLColor DesertSand { get { return FromHtml("#FFEDC9AF"); } } + public static XLColor DesertSand => FromHtml("#FFEDC9AF"); - public static XLColor DogwoodRose { get { return FromHtml("#FFD71868"); } } + public static XLColor DogwoodRose => FromHtml("#FFD71868"); - public static XLColor DollarBill { get { return FromHtml("#FF85BB65"); } } + public static XLColor DollarBill => FromHtml("#FF85BB65"); - public static XLColor Drab { get { return FromHtml("#FF967117"); } } + public static XLColor Drab => FromHtml("#FF967117"); - public static XLColor DukeBlue { get { return FromHtml("#FF00009C"); } } + public static XLColor DukeBlue => FromHtml("#FF00009C"); - public static XLColor EarthYellow { get { return FromHtml("#FFE1A95F"); } } + public static XLColor EarthYellow => FromHtml("#FFE1A95F"); - public static XLColor Ecru { get { return FromHtml("#FFC2B280"); } } + public static XLColor Ecru => FromHtml("#FFC2B280"); - public static XLColor Eggplant { get { return FromHtml("#FF614051"); } } + public static XLColor Eggplant => FromHtml("#FF614051"); - public static XLColor Eggshell { get { return FromHtml("#FFF0EAD6"); } } + public static XLColor Eggshell => FromHtml("#FFF0EAD6"); - public static XLColor EgyptianBlue { get { return FromHtml("#FF1034A6"); } } + public static XLColor EgyptianBlue => FromHtml("#FF1034A6"); - public static XLColor ElectricBlue { get { return FromHtml("#FF7DF9FF"); } } + public static XLColor ElectricBlue => FromHtml("#FF7DF9FF"); - public static XLColor ElectricCrimson { get { return FromHtml("#FFFF003F"); } } + public static XLColor ElectricCrimson => FromHtml("#FFFF003F"); - public static XLColor ElectricIndigo { get { return FromHtml("#FF6F00FF"); } } + public static XLColor ElectricIndigo => FromHtml("#FF6F00FF"); - public static XLColor ElectricLavender { get { return FromHtml("#FFF4BBFF"); } } + public static XLColor ElectricLavender => FromHtml("#FFF4BBFF"); - public static XLColor ElectricLime { get { return FromHtml("#FFCCFF00"); } } + public static XLColor ElectricLime => FromHtml("#FFCCFF00"); - public static XLColor ElectricPurple { get { return FromHtml("#FFBF00FF"); } } + public static XLColor ElectricPurple => FromHtml("#FFBF00FF"); - public static XLColor ElectricUltramarine { get { return FromHtml("#FF3F00FF"); } } + public static XLColor ElectricUltramarine => FromHtml("#FF3F00FF"); - public static XLColor ElectricViolet { get { return FromHtml("#FF8F00FF"); } } + public static XLColor ElectricViolet => FromHtml("#FF8F00FF"); - public static XLColor Emerald { get { return FromHtml("#FF50C878"); } } + public static XLColor Emerald => FromHtml("#FF50C878"); - public static XLColor EtonBlue { get { return FromHtml("#FF96C8A2"); } } + public static XLColor EtonBlue => FromHtml("#FF96C8A2"); - public static XLColor Fallow { get { return FromHtml("#FFC19A6B"); } } + public static XLColor Fallow => FromHtml("#FFC19A6B"); - public static XLColor FaluRed { get { return FromHtml("#FF801818"); } } + public static XLColor FaluRed => FromHtml("#FF801818"); - public static XLColor Fandango { get { return FromHtml("#FFB53389"); } } + public static XLColor Fandango => FromHtml("#FFB53389"); - public static XLColor FashionFuchsia { get { return FromHtml("#FFF400A1"); } } + public static XLColor FashionFuchsia => FromHtml("#FFF400A1"); - public static XLColor Fawn { get { return FromHtml("#FFE5AA70"); } } + public static XLColor Fawn => FromHtml("#FFE5AA70"); - public static XLColor Feldgrau { get { return FromHtml("#FF4D5D53"); } } + public static XLColor Feldgrau => FromHtml("#FF4D5D53"); - public static XLColor FernGreen { get { return FromHtml("#FF4F7942"); } } + public static XLColor FernGreen => FromHtml("#FF4F7942"); - public static XLColor FerrariRed { get { return FromHtml("#FFFF2800"); } } + public static XLColor FerrariRed => FromHtml("#FFFF2800"); - public static XLColor FieldDrab { get { return FromHtml("#FF6C541E"); } } + public static XLColor FieldDrab => FromHtml("#FF6C541E"); - public static XLColor FireEngineRed { get { return FromHtml("#FFCE2029"); } } + public static XLColor FireEngineRed => FromHtml("#FFCE2029"); - public static XLColor Flame { get { return FromHtml("#FFE25822"); } } + public static XLColor Flame => FromHtml("#FFE25822"); - public static XLColor FlamingoPink { get { return FromHtml("#FFFC8EAC"); } } + public static XLColor FlamingoPink => FromHtml("#FFFC8EAC"); - public static XLColor Flavescent { get { return FromHtml("#FFF7E98E"); } } + public static XLColor Flavescent => FromHtml("#FFF7E98E"); - public static XLColor Flax { get { return FromHtml("#FFEEDC82"); } } + public static XLColor Flax => FromHtml("#FFEEDC82"); - public static XLColor FluorescentOrange { get { return FromHtml("#FFFFBF00"); } } + public static XLColor FluorescentOrange => FromHtml("#FFFFBF00"); - public static XLColor FluorescentYellow { get { return FromHtml("#FFCCFF00"); } } + public static XLColor FluorescentYellow => FromHtml("#FFCCFF00"); - public static XLColor Folly { get { return FromHtml("#FFFF004F"); } } + public static XLColor Folly => FromHtml("#FFFF004F"); - public static XLColor ForestGreenTraditional { get { return FromHtml("#FF014421"); } } + public static XLColor ForestGreenTraditional => FromHtml("#FF014421"); - public static XLColor FrenchBeige { get { return FromHtml("#FFA67B5B"); } } + public static XLColor FrenchBeige => FromHtml("#FFA67B5B"); - public static XLColor FrenchBlue { get { return FromHtml("#FF0072BB"); } } + public static XLColor FrenchBlue => FromHtml("#FF0072BB"); - public static XLColor FrenchLilac { get { return FromHtml("#FF86608E"); } } + public static XLColor FrenchLilac => FromHtml("#FF86608E"); - public static XLColor FrenchRose { get { return FromHtml("#FFF64A8A"); } } + public static XLColor FrenchRose => FromHtml("#FFF64A8A"); - public static XLColor FuchsiaPink { get { return FromHtml("#FFFF77FF"); } } + public static XLColor FuchsiaPink => FromHtml("#FFFF77FF"); - public static XLColor Fulvous { get { return FromHtml("#FFE48400"); } } + public static XLColor Fulvous => FromHtml("#FFE48400"); - public static XLColor FuzzyWuzzy { get { return FromHtml("#FFCC6666"); } } + public static XLColor FuzzyWuzzy => FromHtml("#FFCC6666"); - public static XLColor Gamboge { get { return FromHtml("#FFE49B0F"); } } + public static XLColor Gamboge => FromHtml("#FFE49B0F"); - public static XLColor Ginger { get { return FromHtml("#FFF9F9FF"); } } + public static XLColor Ginger => FromHtml("#FFF9F9FF"); - public static XLColor Glaucous { get { return FromHtml("#FF6082B6"); } } + public static XLColor Glaucous => FromHtml("#FF6082B6"); - public static XLColor GoldenBrown { get { return FromHtml("#FF996515"); } } + public static XLColor GoldenBrown => FromHtml("#FF996515"); - public static XLColor GoldenPoppy { get { return FromHtml("#FFFCC200"); } } + public static XLColor GoldenPoppy => FromHtml("#FFFCC200"); - public static XLColor GoldenYellow { get { return FromHtml("#FFFFDF00"); } } + public static XLColor GoldenYellow => FromHtml("#FFFFDF00"); - public static XLColor GoldMetallic { get { return FromHtml("#FFD4AF37"); } } + public static XLColor GoldMetallic => FromHtml("#FFD4AF37"); - public static XLColor GrannySmithApple { get { return FromHtml("#FFA8E4A0"); } } + public static XLColor GrannySmithApple => FromHtml("#FFA8E4A0"); - public static XLColor GrayAsparagus { get { return FromHtml("#FF465945"); } } + public static XLColor GrayAsparagus => FromHtml("#FF465945"); - public static XLColor GreenPigment { get { return FromHtml("#FF00A550"); } } + public static XLColor GreenPigment => FromHtml("#FF00A550"); - public static XLColor GreenRyb { get { return FromHtml("#FF66B032"); } } + public static XLColor GreenRyb => FromHtml("#FF66B032"); - public static XLColor Grullo { get { return FromHtml("#FFA99A86"); } } + public static XLColor Grullo => FromHtml("#FFA99A86"); - public static XLColor HalayaUbe { get { return FromHtml("#FF663854"); } } + public static XLColor HalayaUbe => FromHtml("#FF663854"); - public static XLColor HanBlue { get { return FromHtml("#FF446CCF"); } } + public static XLColor HanBlue => FromHtml("#FF446CCF"); - public static XLColor HanPurple { get { return FromHtml("#FF5218FA"); } } + public static XLColor HanPurple => FromHtml("#FF5218FA"); - public static XLColor HansaYellow { get { return FromHtml("#FFE9D66B"); } } + public static XLColor HansaYellow => FromHtml("#FFE9D66B"); - public static XLColor Harlequin { get { return FromHtml("#FF3FFF00"); } } + public static XLColor Harlequin => FromHtml("#FF3FFF00"); - public static XLColor HarvardCrimson { get { return FromHtml("#FFC90016"); } } + public static XLColor HarvardCrimson => FromHtml("#FFC90016"); - public static XLColor HarvestGold { get { return FromHtml("#FFDA9100"); } } + public static XLColor HarvestGold => FromHtml("#FFDA9100"); - public static XLColor Heliotrope { get { return FromHtml("#FFDF73FF"); } } + public static XLColor Heliotrope => FromHtml("#FFDF73FF"); - public static XLColor HollywoodCerise { get { return FromHtml("#FFF400A1"); } } + public static XLColor HollywoodCerise => FromHtml("#FFF400A1"); - public static XLColor HookersGreen { get { return FromHtml("#FF007000"); } } + public static XLColor HookersGreen => FromHtml("#FF007000"); - public static XLColor HotMagenta { get { return FromHtml("#FFFF1DCE"); } } + public static XLColor HotMagenta => FromHtml("#FFFF1DCE"); - public static XLColor HunterGreen { get { return FromHtml("#FF355E3B"); } } + public static XLColor HunterGreen => FromHtml("#FF355E3B"); - public static XLColor Iceberg { get { return FromHtml("#FF71A6D2"); } } + public static XLColor Iceberg => FromHtml("#FF71A6D2"); - public static XLColor Icterine { get { return FromHtml("#FFFCF75E"); } } + public static XLColor Icterine => FromHtml("#FFFCF75E"); - public static XLColor Inchworm { get { return FromHtml("#FFB2EC5D"); } } + public static XLColor Inchworm => FromHtml("#FFB2EC5D"); - public static XLColor IndiaGreen { get { return FromHtml("#FF138808"); } } + public static XLColor IndiaGreen => FromHtml("#FF138808"); - public static XLColor IndianYellow { get { return FromHtml("#FFE3A857"); } } + public static XLColor IndianYellow => FromHtml("#FFE3A857"); - public static XLColor IndigoDye { get { return FromHtml("#FF00416A"); } } + public static XLColor IndigoDye => FromHtml("#FF00416A"); - public static XLColor InternationalKleinBlue { get { return FromHtml("#FF002FA7"); } } + public static XLColor InternationalKleinBlue => FromHtml("#FF002FA7"); - public static XLColor InternationalOrange { get { return FromHtml("#FFFF4F00"); } } + public static XLColor InternationalOrange => FromHtml("#FFFF4F00"); - public static XLColor Iris { get { return FromHtml("#FF5A4FCF"); } } + public static XLColor Iris => FromHtml("#FF5A4FCF"); - public static XLColor Isabelline { get { return FromHtml("#FFF4F0EC"); } } + public static XLColor Isabelline => FromHtml("#FFF4F0EC"); - public static XLColor IslamicGreen { get { return FromHtml("#FF009000"); } } + public static XLColor IslamicGreen => FromHtml("#FF009000"); - public static XLColor Jade { get { return FromHtml("#FF00A86B"); } } + public static XLColor Jade => FromHtml("#FF00A86B"); - public static XLColor Jasper { get { return FromHtml("#FFD73B3E"); } } + public static XLColor Jasper => FromHtml("#FFD73B3E"); - public static XLColor JazzberryJam { get { return FromHtml("#FFA50B5E"); } } + public static XLColor JazzberryJam => FromHtml("#FFA50B5E"); - public static XLColor Jonquil { get { return FromHtml("#FFFADA5E"); } } + public static XLColor Jonquil => FromHtml("#FFFADA5E"); - public static XLColor JuneBud { get { return FromHtml("#FFBDDA57"); } } + public static XLColor JuneBud => FromHtml("#FFBDDA57"); - public static XLColor JungleGreen { get { return FromHtml("#FF29AB87"); } } + public static XLColor JungleGreen => FromHtml("#FF29AB87"); - public static XLColor KellyGreen { get { return FromHtml("#FF4CBB17"); } } + public static XLColor KellyGreen => FromHtml("#FF4CBB17"); - public static XLColor KhakiHtmlCssKhaki { get { return FromHtml("#FFC3B091"); } } + public static XLColor KhakiHtmlCssKhaki => FromHtml("#FFC3B091"); - public static XLColor LanguidLavender { get { return FromHtml("#FFD6CADD"); } } + public static XLColor LanguidLavender => FromHtml("#FFD6CADD"); - public static XLColor LapisLazuli { get { return FromHtml("#FF26619C"); } } + public static XLColor LapisLazuli => FromHtml("#FF26619C"); - public static XLColor LaSalleGreen { get { return FromHtml("#FF087830"); } } + public static XLColor LaSalleGreen => FromHtml("#FF087830"); - public static XLColor LaserLemon { get { return FromHtml("#FFFEFE22"); } } + public static XLColor LaserLemon => FromHtml("#FFFEFE22"); - public static XLColor Lava { get { return FromHtml("#FFCF1020"); } } + public static XLColor Lava => FromHtml("#FFCF1020"); - public static XLColor LavenderBlue { get { return FromHtml("#FFCCCCFF"); } } + public static XLColor LavenderBlue => FromHtml("#FFCCCCFF"); - public static XLColor LavenderFloral { get { return FromHtml("#FFB57EDC"); } } + public static XLColor LavenderFloral => FromHtml("#FFB57EDC"); - public static XLColor LavenderGray { get { return FromHtml("#FFC4C3D0"); } } + public static XLColor LavenderGray => FromHtml("#FFC4C3D0"); - public static XLColor LavenderIndigo { get { return FromHtml("#FF9457EB"); } } + public static XLColor LavenderIndigo => FromHtml("#FF9457EB"); - public static XLColor LavenderPink { get { return FromHtml("#FFFBAED2"); } } + public static XLColor LavenderPink => FromHtml("#FFFBAED2"); - public static XLColor LavenderPurple { get { return FromHtml("#FF967BB6"); } } + public static XLColor LavenderPurple => FromHtml("#FF967BB6"); - public static XLColor LavenderRose { get { return FromHtml("#FFFBA0E3"); } } + public static XLColor LavenderRose => FromHtml("#FFFBA0E3"); - public static XLColor Lemon { get { return FromHtml("#FFFFF700"); } } + public static XLColor Lemon => FromHtml("#FFFFF700"); - public static XLColor LightApricot { get { return FromHtml("#FFFDD5B1"); } } + public static XLColor LightApricot => FromHtml("#FFFDD5B1"); - public static XLColor LightBrown { get { return FromHtml("#FFB5651D"); } } + public static XLColor LightBrown => FromHtml("#FFB5651D"); - public static XLColor LightCarminePink { get { return FromHtml("#FFE66771"); } } + public static XLColor LightCarminePink => FromHtml("#FFE66771"); - public static XLColor LightCornflowerBlue { get { return FromHtml("#FF93CCEA"); } } + public static XLColor LightCornflowerBlue => FromHtml("#FF93CCEA"); - public static XLColor LightFuchsiaPink { get { return FromHtml("#FFF984EF"); } } + public static XLColor LightFuchsiaPink => FromHtml("#FFF984EF"); - public static XLColor LightMauve { get { return FromHtml("#FFDCD0FF"); } } + public static XLColor LightMauve => FromHtml("#FFDCD0FF"); - public static XLColor LightPastelPurple { get { return FromHtml("#FFB19CD9"); } } + public static XLColor LightPastelPurple => FromHtml("#FFB19CD9"); - public static XLColor LightSalmonPink { get { return FromHtml("#FFFF9999"); } } + public static XLColor LightSalmonPink => FromHtml("#FFFF9999"); - public static XLColor LightTaupe { get { return FromHtml("#FFB38B6D"); } } + public static XLColor LightTaupe => FromHtml("#FFB38B6D"); - public static XLColor LightThulianPink { get { return FromHtml("#FFE68FAC"); } } + public static XLColor LightThulianPink => FromHtml("#FFE68FAC"); - public static XLColor LightYellow1 { get { return FromHtml("#FFFFFFED"); } } + public static XLColor LightYellow1 => FromHtml("#FFFFFFED"); - public static XLColor Lilac { get { return FromHtml("#FFC8A2C8"); } } + public static XLColor Lilac => FromHtml("#FFC8A2C8"); - public static XLColor LimeColorWheel { get { return FromHtml("#FFBFFF00"); } } + public static XLColor LimeColorWheel => FromHtml("#FFBFFF00"); - public static XLColor LincolnGreen { get { return FromHtml("#FF195905"); } } + public static XLColor LincolnGreen => FromHtml("#FF195905"); - public static XLColor Liver { get { return FromHtml("#FF534B4F"); } } + public static XLColor Liver => FromHtml("#FF534B4F"); - public static XLColor Lust { get { return FromHtml("#FFE62020"); } } + public static XLColor Lust => FromHtml("#FFE62020"); - public static XLColor MacaroniAndCheese { get { return FromHtml("#FFFFBD88"); } } + public static XLColor MacaroniAndCheese => FromHtml("#FFFFBD88"); - public static XLColor MagentaDye { get { return FromHtml("#FFCA1F7B"); } } + public static XLColor MagentaDye => FromHtml("#FFCA1F7B"); - public static XLColor MagentaProcess { get { return FromHtml("#FFFF0090"); } } + public static XLColor MagentaProcess => FromHtml("#FFFF0090"); - public static XLColor MagicMint { get { return FromHtml("#FFAAF0D1"); } } + public static XLColor MagicMint => FromHtml("#FFAAF0D1"); - public static XLColor Magnolia { get { return FromHtml("#FFF8F4FF"); } } + public static XLColor Magnolia => FromHtml("#FFF8F4FF"); - public static XLColor Mahogany { get { return FromHtml("#FFC04000"); } } + public static XLColor Mahogany => FromHtml("#FFC04000"); - public static XLColor Maize { get { return FromHtml("#FFFBEC5D"); } } + public static XLColor Maize => FromHtml("#FFFBEC5D"); - public static XLColor MajorelleBlue { get { return FromHtml("#FF6050DC"); } } + public static XLColor MajorelleBlue => FromHtml("#FF6050DC"); - public static XLColor Malachite { get { return FromHtml("#FF0BDA51"); } } + public static XLColor Malachite => FromHtml("#FF0BDA51"); - public static XLColor Manatee { get { return FromHtml("#FF979AAA"); } } + public static XLColor Manatee => FromHtml("#FF979AAA"); - public static XLColor MangoTango { get { return FromHtml("#FFFF8243"); } } + public static XLColor MangoTango => FromHtml("#FFFF8243"); - public static XLColor MaroonX11 { get { return FromHtml("#FFB03060"); } } + public static XLColor MaroonX11 => FromHtml("#FFB03060"); - public static XLColor Mauve { get { return FromHtml("#FFE0B0FF"); } } + public static XLColor Mauve => FromHtml("#FFE0B0FF"); - public static XLColor Mauvelous { get { return FromHtml("#FFEF98AA"); } } + public static XLColor Mauvelous => FromHtml("#FFEF98AA"); - public static XLColor MauveTaupe { get { return FromHtml("#FF915F6D"); } } + public static XLColor MauveTaupe => FromHtml("#FF915F6D"); - public static XLColor MayaBlue { get { return FromHtml("#FF73C2FB"); } } + public static XLColor MayaBlue => FromHtml("#FF73C2FB"); - public static XLColor MeatBrown { get { return FromHtml("#FFE5B73B"); } } + public static XLColor MeatBrown => FromHtml("#FFE5B73B"); - public static XLColor MediumAquamarine1 { get { return FromHtml("#FF66DDAA"); } } + public static XLColor MediumAquamarine1 => FromHtml("#FF66DDAA"); - public static XLColor MediumCandyAppleRed { get { return FromHtml("#FFE2062C"); } } + public static XLColor MediumCandyAppleRed => FromHtml("#FFE2062C"); - public static XLColor MediumCarmine { get { return FromHtml("#FFAF4035"); } } + public static XLColor MediumCarmine => FromHtml("#FFAF4035"); - public static XLColor MediumChampagne { get { return FromHtml("#FFF3E5AB"); } } + public static XLColor MediumChampagne => FromHtml("#FFF3E5AB"); - public static XLColor MediumElectricBlue { get { return FromHtml("#FF035096"); } } + public static XLColor MediumElectricBlue => FromHtml("#FF035096"); - public static XLColor MediumJungleGreen { get { return FromHtml("#FF1C352D"); } } + public static XLColor MediumJungleGreen => FromHtml("#FF1C352D"); - public static XLColor MediumPersianBlue { get { return FromHtml("#FF0067A5"); } } + public static XLColor MediumPersianBlue => FromHtml("#FF0067A5"); - public static XLColor MediumRedViolet { get { return FromHtml("#FFBB3385"); } } + public static XLColor MediumRedViolet => FromHtml("#FFBB3385"); - public static XLColor MediumSpringBud { get { return FromHtml("#FFC9DC87"); } } + public static XLColor MediumSpringBud => FromHtml("#FFC9DC87"); - public static XLColor MediumTaupe { get { return FromHtml("#FF674C47"); } } + public static XLColor MediumTaupe => FromHtml("#FF674C47"); - public static XLColor Melon { get { return FromHtml("#FFFDBCB4"); } } + public static XLColor Melon => FromHtml("#FFFDBCB4"); - public static XLColor MidnightGreenEagleGreen { get { return FromHtml("#FF004953"); } } + public static XLColor MidnightGreenEagleGreen => FromHtml("#FF004953"); - public static XLColor MikadoYellow { get { return FromHtml("#FFFFC40C"); } } + public static XLColor MikadoYellow => FromHtml("#FFFFC40C"); - public static XLColor Mint { get { return FromHtml("#FF3EB489"); } } + public static XLColor Mint => FromHtml("#FF3EB489"); - public static XLColor MintGreen { get { return FromHtml("#FF98FF98"); } } + public static XLColor MintGreen => FromHtml("#FF98FF98"); - public static XLColor ModeBeige { get { return FromHtml("#FF967117"); } } + public static XLColor ModeBeige => FromHtml("#FF967117"); - public static XLColor MoonstoneBlue { get { return FromHtml("#FF73A9C2"); } } + public static XLColor MoonstoneBlue => FromHtml("#FF73A9C2"); - public static XLColor MordantRed19 { get { return FromHtml("#FFAE0C00"); } } + public static XLColor MordantRed19 => FromHtml("#FFAE0C00"); - public static XLColor MossGreen { get { return FromHtml("#FFADDFAD"); } } + public static XLColor MossGreen => FromHtml("#FFADDFAD"); - public static XLColor MountainMeadow { get { return FromHtml("#FF30BA8F"); } } + public static XLColor MountainMeadow => FromHtml("#FF30BA8F"); - public static XLColor MountbattenPink { get { return FromHtml("#FF997A8D"); } } + public static XLColor MountbattenPink => FromHtml("#FF997A8D"); - public static XLColor MsuGreen { get { return FromHtml("#FF18453B"); } } + public static XLColor MsuGreen => FromHtml("#FF18453B"); - public static XLColor Mulberry { get { return FromHtml("#FFC54B8C"); } } + public static XLColor Mulberry => FromHtml("#FFC54B8C"); - public static XLColor Mustard { get { return FromHtml("#FFFFDB58"); } } + public static XLColor Mustard => FromHtml("#FFFFDB58"); - public static XLColor Myrtle { get { return FromHtml("#FF21421E"); } } + public static XLColor Myrtle => FromHtml("#FF21421E"); - public static XLColor NadeshikoPink { get { return FromHtml("#FFF6ADC6"); } } + public static XLColor NadeshikoPink => FromHtml("#FFF6ADC6"); - public static XLColor NapierGreen { get { return FromHtml("#FF2A8000"); } } + public static XLColor NapierGreen => FromHtml("#FF2A8000"); - public static XLColor NaplesYellow { get { return FromHtml("#FFFADA5E"); } } + public static XLColor NaplesYellow => FromHtml("#FFFADA5E"); - public static XLColor NeonCarrot { get { return FromHtml("#FFFFA343"); } } + public static XLColor NeonCarrot => FromHtml("#FFFFA343"); - public static XLColor NeonFuchsia { get { return FromHtml("#FFFE59C2"); } } + public static XLColor NeonFuchsia => FromHtml("#FFFE59C2"); - public static XLColor NeonGreen { get { return FromHtml("#FF39FF14"); } } + public static XLColor NeonGreen => FromHtml("#FF39FF14"); - public static XLColor NonPhotoBlue { get { return FromHtml("#FFA4DDED"); } } + public static XLColor NonPhotoBlue => FromHtml("#FFA4DDED"); - public static XLColor OceanBoatBlue { get { return FromHtml("#FFCC7422"); } } + public static XLColor OceanBoatBlue => FromHtml("#FFCC7422"); - public static XLColor Ochre { get { return FromHtml("#FFCC7722"); } } + public static XLColor Ochre => FromHtml("#FFCC7722"); - public static XLColor OldGold { get { return FromHtml("#FFCFB53B"); } } + public static XLColor OldGold => FromHtml("#FFCFB53B"); - public static XLColor OldLavender { get { return FromHtml("#FF796878"); } } + public static XLColor OldLavender => FromHtml("#FF796878"); - public static XLColor OldMauve { get { return FromHtml("#FF673147"); } } + public static XLColor OldMauve => FromHtml("#FF673147"); - public static XLColor OldRose { get { return FromHtml("#FFC08081"); } } + public static XLColor OldRose => FromHtml("#FFC08081"); - public static XLColor OliveDrab7 { get { return FromHtml("#FF3C341F"); } } + public static XLColor OliveDrab7 => FromHtml("#FF3C341F"); - public static XLColor Olivine { get { return FromHtml("#FF9AB973"); } } + public static XLColor Olivine => FromHtml("#FF9AB973"); - public static XLColor Onyx { get { return FromHtml("#FF0F0F0F"); } } + public static XLColor Onyx => FromHtml("#FF0F0F0F"); - public static XLColor OperaMauve { get { return FromHtml("#FFB784A7"); } } + public static XLColor OperaMauve => FromHtml("#FFB784A7"); - public static XLColor OrangeColorWheel { get { return FromHtml("#FFFF7F00"); } } + public static XLColor OrangeColorWheel => FromHtml("#FFFF7F00"); - public static XLColor OrangePeel { get { return FromHtml("#FFFF9F00"); } } + public static XLColor OrangePeel => FromHtml("#FFFF9F00"); - public static XLColor OrangeRyb { get { return FromHtml("#FFFB9902"); } } + public static XLColor OrangeRyb => FromHtml("#FFFB9902"); - public static XLColor OtterBrown { get { return FromHtml("#FF654321"); } } + public static XLColor OtterBrown => FromHtml("#FF654321"); - public static XLColor OuCrimsonRed { get { return FromHtml("#FF990000"); } } + public static XLColor OuCrimsonRed => FromHtml("#FF990000"); - public static XLColor OuterSpace { get { return FromHtml("#FF414A4C"); } } + public static XLColor OuterSpace => FromHtml("#FF414A4C"); - public static XLColor OutrageousOrange { get { return FromHtml("#FFFF6E4A"); } } + public static XLColor OutrageousOrange => FromHtml("#FFFF6E4A"); - public static XLColor OxfordBlue { get { return FromHtml("#FF002147"); } } + public static XLColor OxfordBlue => FromHtml("#FF002147"); - public static XLColor PakistanGreen { get { return FromHtml("#FF00421B"); } } + public static XLColor PakistanGreen => FromHtml("#FF00421B"); - public static XLColor PalatinateBlue { get { return FromHtml("#FF273BE2"); } } + public static XLColor PalatinateBlue => FromHtml("#FF273BE2"); - public static XLColor PalatinatePurple { get { return FromHtml("#FF682860"); } } + public static XLColor PalatinatePurple => FromHtml("#FF682860"); - public static XLColor PaleAqua { get { return FromHtml("#FFBCD4E6"); } } + public static XLColor PaleAqua => FromHtml("#FFBCD4E6"); - public static XLColor PaleBrown { get { return FromHtml("#FF987654"); } } + public static XLColor PaleBrown => FromHtml("#FF987654"); - public static XLColor PaleCarmine { get { return FromHtml("#FFAF4035"); } } + public static XLColor PaleCarmine => FromHtml("#FFAF4035"); - public static XLColor PaleCerulean { get { return FromHtml("#FF9BC4E2"); } } + public static XLColor PaleCerulean => FromHtml("#FF9BC4E2"); - public static XLColor PaleChestnut { get { return FromHtml("#FFDDADAF"); } } + public static XLColor PaleChestnut => FromHtml("#FFDDADAF"); - public static XLColor PaleCopper { get { return FromHtml("#FFDA8A67"); } } + public static XLColor PaleCopper => FromHtml("#FFDA8A67"); - public static XLColor PaleCornflowerBlue { get { return FromHtml("#FFABCDEF"); } } + public static XLColor PaleCornflowerBlue => FromHtml("#FFABCDEF"); - public static XLColor PaleGold { get { return FromHtml("#FFE6BE8A"); } } + public static XLColor PaleGold => FromHtml("#FFE6BE8A"); - public static XLColor PaleMagenta { get { return FromHtml("#FFF984E5"); } } + public static XLColor PaleMagenta => FromHtml("#FFF984E5"); - public static XLColor PalePink { get { return FromHtml("#FFFADADD"); } } + public static XLColor PalePink => FromHtml("#FFFADADD"); - public static XLColor PaleRobinEggBlue { get { return FromHtml("#FF96DED1"); } } + public static XLColor PaleRobinEggBlue => FromHtml("#FF96DED1"); - public static XLColor PaleSilver { get { return FromHtml("#FFC9C0BB"); } } + public static XLColor PaleSilver => FromHtml("#FFC9C0BB"); - public static XLColor PaleSpringBud { get { return FromHtml("#FFECEBBD"); } } + public static XLColor PaleSpringBud => FromHtml("#FFECEBBD"); - public static XLColor PaleTaupe { get { return FromHtml("#FFBC987E"); } } + public static XLColor PaleTaupe => FromHtml("#FFBC987E"); - public static XLColor PansyPurple { get { return FromHtml("#FF78184A"); } } + public static XLColor PansyPurple => FromHtml("#FF78184A"); - public static XLColor ParisGreen { get { return FromHtml("#FF50C878"); } } + public static XLColor ParisGreen => FromHtml("#FF50C878"); - public static XLColor PastelBlue { get { return FromHtml("#FFAEC6CF"); } } + public static XLColor PastelBlue => FromHtml("#FFAEC6CF"); - public static XLColor PastelBrown { get { return FromHtml("#FF836953"); } } + public static XLColor PastelBrown => FromHtml("#FF836953"); - public static XLColor PastelGray { get { return FromHtml("#FFCFCFC4"); } } + public static XLColor PastelGray => FromHtml("#FFCFCFC4"); - public static XLColor PastelGreen { get { return FromHtml("#FF77DD77"); } } + public static XLColor PastelGreen => FromHtml("#FF77DD77"); - public static XLColor PastelMagenta { get { return FromHtml("#FFF49AC2"); } } + public static XLColor PastelMagenta => FromHtml("#FFF49AC2"); - public static XLColor PastelOrange { get { return FromHtml("#FFFFB347"); } } + public static XLColor PastelOrange => FromHtml("#FFFFB347"); - public static XLColor PastelPink { get { return FromHtml("#FFFFD1DC"); } } + public static XLColor PastelPink => FromHtml("#FFFFD1DC"); - public static XLColor PastelPurple { get { return FromHtml("#FFB39EB5"); } } + public static XLColor PastelPurple => FromHtml("#FFB39EB5"); - public static XLColor PastelRed { get { return FromHtml("#FFFF6961"); } } + public static XLColor PastelRed => FromHtml("#FFFF6961"); - public static XLColor PastelViolet { get { return FromHtml("#FFCB99C9"); } } + public static XLColor PastelViolet => FromHtml("#FFCB99C9"); - public static XLColor PastelYellow { get { return FromHtml("#FFFDFD96"); } } + public static XLColor PastelYellow => FromHtml("#FFFDFD96"); - public static XLColor PaynesGrey { get { return FromHtml("#FF40404F"); } } + public static XLColor PaynesGrey => FromHtml("#FF40404F"); - public static XLColor Peach { get { return FromHtml("#FFFFE5B4"); } } + public static XLColor Peach => FromHtml("#FFFFE5B4"); - public static XLColor PeachOrange { get { return FromHtml("#FFFFCC99"); } } + public static XLColor PeachOrange => FromHtml("#FFFFCC99"); - public static XLColor PeachYellow { get { return FromHtml("#FFFADFAD"); } } + public static XLColor PeachYellow => FromHtml("#FFFADFAD"); - public static XLColor Pear { get { return FromHtml("#FFD1E231"); } } + public static XLColor Pear => FromHtml("#FFD1E231"); - public static XLColor Pearl { get { return FromHtml("#FFF0EAD6"); } } + public static XLColor Pearl => FromHtml("#FFF0EAD6"); - public static XLColor Peridot { get { return FromHtml("#FFE6E200"); } } + public static XLColor Peridot => FromHtml("#FFE6E200"); - public static XLColor Periwinkle { get { return FromHtml("#FFCCCCFF"); } } + public static XLColor Periwinkle => FromHtml("#FFCCCCFF"); - public static XLColor PersianBlue { get { return FromHtml("#FF1C39BB"); } } + public static XLColor PersianBlue => FromHtml("#FF1C39BB"); - public static XLColor PersianGreen { get { return FromHtml("#FF00A693"); } } + public static XLColor PersianGreen => FromHtml("#FF00A693"); - public static XLColor PersianIndigo { get { return FromHtml("#FF32127A"); } } + public static XLColor PersianIndigo => FromHtml("#FF32127A"); - public static XLColor PersianOrange { get { return FromHtml("#FFD99058"); } } + public static XLColor PersianOrange => FromHtml("#FFD99058"); - public static XLColor PersianPink { get { return FromHtml("#FFF77FBE"); } } + public static XLColor PersianPink => FromHtml("#FFF77FBE"); - public static XLColor PersianPlum { get { return FromHtml("#FF701C1C"); } } + public static XLColor PersianPlum => FromHtml("#FF701C1C"); - public static XLColor PersianRed { get { return FromHtml("#FFCC3333"); } } + public static XLColor PersianRed => FromHtml("#FFCC3333"); - public static XLColor PersianRose { get { return FromHtml("#FFFE28A2"); } } + public static XLColor PersianRose => FromHtml("#FFFE28A2"); - public static XLColor Persimmon { get { return FromHtml("#FFEC5800"); } } + public static XLColor Persimmon => FromHtml("#FFEC5800"); - public static XLColor Phlox { get { return FromHtml("#FFDF00FF"); } } + public static XLColor Phlox => FromHtml("#FFDF00FF"); - public static XLColor PhthaloBlue { get { return FromHtml("#FF000F89"); } } + public static XLColor PhthaloBlue => FromHtml("#FF000F89"); - public static XLColor PhthaloGreen { get { return FromHtml("#FF123524"); } } + public static XLColor PhthaloGreen => FromHtml("#FF123524"); - public static XLColor PiggyPink { get { return FromHtml("#FFFDDDE6"); } } + public static XLColor PiggyPink => FromHtml("#FFFDDDE6"); - public static XLColor PineGreen { get { return FromHtml("#FF01796F"); } } + public static XLColor PineGreen => FromHtml("#FF01796F"); - public static XLColor PinkOrange { get { return FromHtml("#FFFF9966"); } } + public static XLColor PinkOrange => FromHtml("#FFFF9966"); - public static XLColor PinkPearl { get { return FromHtml("#FFE7ACCF"); } } + public static XLColor PinkPearl => FromHtml("#FFE7ACCF"); - public static XLColor PinkSherbet { get { return FromHtml("#FFF78FA7"); } } + public static XLColor PinkSherbet => FromHtml("#FFF78FA7"); - public static XLColor Pistachio { get { return FromHtml("#FF93C572"); } } + public static XLColor Pistachio => FromHtml("#FF93C572"); - public static XLColor Platinum { get { return FromHtml("#FFE5E4E2"); } } + public static XLColor Platinum => FromHtml("#FFE5E4E2"); - public static XLColor PlumTraditional { get { return FromHtml("#FF8E4585"); } } + public static XLColor PlumTraditional => FromHtml("#FF8E4585"); - public static XLColor PortlandOrange { get { return FromHtml("#FFFF5A36"); } } + public static XLColor PortlandOrange => FromHtml("#FFFF5A36"); - public static XLColor PrincetonOrange { get { return FromHtml("#FFFF8F00"); } } + public static XLColor PrincetonOrange => FromHtml("#FFFF8F00"); - public static XLColor Prune { get { return FromHtml("#FF701C1C"); } } + public static XLColor Prune => FromHtml("#FF701C1C"); - public static XLColor PrussianBlue { get { return FromHtml("#FF003153"); } } + public static XLColor PrussianBlue => FromHtml("#FF003153"); - public static XLColor PsychedelicPurple { get { return FromHtml("#FFDF00FF"); } } + public static XLColor PsychedelicPurple => FromHtml("#FFDF00FF"); - public static XLColor Puce { get { return FromHtml("#FFCC8899"); } } + public static XLColor Puce => FromHtml("#FFCC8899"); - public static XLColor Pumpkin { get { return FromHtml("#FFFF7518"); } } + public static XLColor Pumpkin => FromHtml("#FFFF7518"); - public static XLColor PurpleHeart { get { return FromHtml("#FF69359C"); } } + public static XLColor PurpleHeart => FromHtml("#FF69359C"); - public static XLColor PurpleMountainMajesty { get { return FromHtml("#FF9678B6"); } } + public static XLColor PurpleMountainMajesty => FromHtml("#FF9678B6"); - public static XLColor PurpleMunsell { get { return FromHtml("#FF9F00C5"); } } + public static XLColor PurpleMunsell => FromHtml("#FF9F00C5"); - public static XLColor PurplePizzazz { get { return FromHtml("#FFFE4EDA"); } } + public static XLColor PurplePizzazz => FromHtml("#FFFE4EDA"); - public static XLColor PurpleTaupe { get { return FromHtml("#FF50404D"); } } + public static XLColor PurpleTaupe => FromHtml("#FF50404D"); - public static XLColor PurpleX11 { get { return FromHtml("#FFA020F0"); } } + public static XLColor PurpleX11 => FromHtml("#FFA020F0"); - public static XLColor RadicalRed { get { return FromHtml("#FFFF355E"); } } + public static XLColor RadicalRed => FromHtml("#FFFF355E"); - public static XLColor Raspberry { get { return FromHtml("#FFE30B5D"); } } + public static XLColor Raspberry => FromHtml("#FFE30B5D"); - public static XLColor RaspberryGlace { get { return FromHtml("#FF915F6D"); } } + public static XLColor RaspberryGlace => FromHtml("#FF915F6D"); - public static XLColor RaspberryPink { get { return FromHtml("#FFE25098"); } } + public static XLColor RaspberryPink => FromHtml("#FFE25098"); - public static XLColor RaspberryRose { get { return FromHtml("#FFB3446C"); } } + public static XLColor RaspberryRose => FromHtml("#FFB3446C"); - public static XLColor RawUmber { get { return FromHtml("#FF826644"); } } + public static XLColor RawUmber => FromHtml("#FF826644"); - public static XLColor RazzleDazzleRose { get { return FromHtml("#FFFF33CC"); } } + public static XLColor RazzleDazzleRose => FromHtml("#FFFF33CC"); - public static XLColor Razzmatazz { get { return FromHtml("#FFE3256B"); } } + public static XLColor Razzmatazz => FromHtml("#FFE3256B"); - public static XLColor RedMunsell { get { return FromHtml("#FFF2003C"); } } + public static XLColor RedMunsell => FromHtml("#FFF2003C"); - public static XLColor RedNcs { get { return FromHtml("#FFC40233"); } } + public static XLColor RedNcs => FromHtml("#FFC40233"); - public static XLColor RedPigment { get { return FromHtml("#FFED1C24"); } } + public static XLColor RedPigment => FromHtml("#FFED1C24"); - public static XLColor RedRyb { get { return FromHtml("#FFFE2712"); } } + public static XLColor RedRyb => FromHtml("#FFFE2712"); - public static XLColor Redwood { get { return FromHtml("#FFAB4E52"); } } + public static XLColor Redwood => FromHtml("#FFAB4E52"); - public static XLColor Regalia { get { return FromHtml("#FF522D80"); } } + public static XLColor Regalia => FromHtml("#FF522D80"); - public static XLColor RichBlack { get { return FromHtml("#FF004040"); } } + public static XLColor RichBlack => FromHtml("#FF004040"); - public static XLColor RichBrilliantLavender { get { return FromHtml("#FFF1A7FE"); } } + public static XLColor RichBrilliantLavender => FromHtml("#FFF1A7FE"); - public static XLColor RichCarmine { get { return FromHtml("#FFD70040"); } } + public static XLColor RichCarmine => FromHtml("#FFD70040"); - public static XLColor RichElectricBlue { get { return FromHtml("#FF0892D0"); } } + public static XLColor RichElectricBlue => FromHtml("#FF0892D0"); - public static XLColor RichLavender { get { return FromHtml("#FFA76BCF"); } } + public static XLColor RichLavender => FromHtml("#FFA76BCF"); - public static XLColor RichLilac { get { return FromHtml("#FFB666D2"); } } + public static XLColor RichLilac => FromHtml("#FFB666D2"); - public static XLColor RichMaroon { get { return FromHtml("#FFB03060"); } } + public static XLColor RichMaroon => FromHtml("#FFB03060"); - public static XLColor RifleGreen { get { return FromHtml("#FF414833"); } } + public static XLColor RifleGreen => FromHtml("#FF414833"); - public static XLColor RobinEggBlue { get { return FromHtml("#FF00CCCC"); } } + public static XLColor RobinEggBlue => FromHtml("#FF00CCCC"); - public static XLColor Rose { get { return FromHtml("#FFFF007F"); } } + public static XLColor Rose => FromHtml("#FFFF007F"); - public static XLColor RoseBonbon { get { return FromHtml("#FFF9429E"); } } + public static XLColor RoseBonbon => FromHtml("#FFF9429E"); - public static XLColor RoseEbony { get { return FromHtml("#FF674846"); } } + public static XLColor RoseEbony => FromHtml("#FF674846"); - public static XLColor RoseGold { get { return FromHtml("#FFB76E79"); } } + public static XLColor RoseGold => FromHtml("#FFB76E79"); - public static XLColor RoseMadder { get { return FromHtml("#FFE32636"); } } + public static XLColor RoseMadder => FromHtml("#FFE32636"); - public static XLColor RosePink { get { return FromHtml("#FFFF66CC"); } } + public static XLColor RosePink => FromHtml("#FFFF66CC"); - public static XLColor RoseQuartz { get { return FromHtml("#FFAA98A9"); } } + public static XLColor RoseQuartz => FromHtml("#FFAA98A9"); - public static XLColor RoseTaupe { get { return FromHtml("#FF905D5D"); } } + public static XLColor RoseTaupe => FromHtml("#FF905D5D"); - public static XLColor RoseVale { get { return FromHtml("#FFAB4E52"); } } + public static XLColor RoseVale => FromHtml("#FFAB4E52"); - public static XLColor Rosewood { get { return FromHtml("#FF65000B"); } } + public static XLColor Rosewood => FromHtml("#FF65000B"); - public static XLColor RossoCorsa { get { return FromHtml("#FFD40000"); } } + public static XLColor RossoCorsa => FromHtml("#FFD40000"); - public static XLColor RoyalAzure { get { return FromHtml("#FF0038A8"); } } + public static XLColor RoyalAzure => FromHtml("#FF0038A8"); - public static XLColor RoyalBlueTraditional { get { return FromHtml("#FF002366"); } } + public static XLColor RoyalBlueTraditional => FromHtml("#FF002366"); - public static XLColor RoyalFuchsia { get { return FromHtml("#FFCA2C92"); } } + public static XLColor RoyalFuchsia => FromHtml("#FFCA2C92"); - public static XLColor RoyalPurple { get { return FromHtml("#FF7851A9"); } } + public static XLColor RoyalPurple => FromHtml("#FF7851A9"); - public static XLColor Ruby { get { return FromHtml("#FFE0115F"); } } + public static XLColor Ruby => FromHtml("#FFE0115F"); - public static XLColor Ruddy { get { return FromHtml("#FFFF0028"); } } + public static XLColor Ruddy => FromHtml("#FFFF0028"); - public static XLColor RuddyBrown { get { return FromHtml("#FFBB6528"); } } + public static XLColor RuddyBrown => FromHtml("#FFBB6528"); - public static XLColor RuddyPink { get { return FromHtml("#FFE18E96"); } } + public static XLColor RuddyPink => FromHtml("#FFE18E96"); - public static XLColor Rufous { get { return FromHtml("#FFA81C07"); } } + public static XLColor Rufous => FromHtml("#FFA81C07"); - public static XLColor Russet { get { return FromHtml("#FF80461B"); } } + public static XLColor Russet => FromHtml("#FF80461B"); - public static XLColor Rust { get { return FromHtml("#FFB7410E"); } } + public static XLColor Rust => FromHtml("#FFB7410E"); - public static XLColor SacramentoStateGreen { get { return FromHtml("#FF00563F"); } } + public static XLColor SacramentoStateGreen => FromHtml("#FF00563F"); - public static XLColor SafetyOrangeBlazeOrange { get { return FromHtml("#FFFF6700"); } } + public static XLColor SafetyOrangeBlazeOrange => FromHtml("#FFFF6700"); - public static XLColor Saffron { get { return FromHtml("#FFF4C430"); } } + public static XLColor Saffron => FromHtml("#FFF4C430"); - public static XLColor Salmon1 { get { return FromHtml("#FFFF8C69"); } } + public static XLColor Salmon1 => FromHtml("#FFFF8C69"); - public static XLColor SalmonPink { get { return FromHtml("#FFFF91A4"); } } + public static XLColor SalmonPink => FromHtml("#FFFF91A4"); - public static XLColor Sand { get { return FromHtml("#FFC2B280"); } } + public static XLColor Sand => FromHtml("#FFC2B280"); - public static XLColor SandDune { get { return FromHtml("#FF967117"); } } + public static XLColor SandDune => FromHtml("#FF967117"); - public static XLColor Sandstorm { get { return FromHtml("#FFECD540"); } } + public static XLColor Sandstorm => FromHtml("#FFECD540"); - public static XLColor SandyTaupe { get { return FromHtml("#FF967117"); } } + public static XLColor SandyTaupe => FromHtml("#FF967117"); - public static XLColor Sangria { get { return FromHtml("#FF92000A"); } } + public static XLColor Sangria => FromHtml("#FF92000A"); - public static XLColor SapGreen { get { return FromHtml("#FF507D2A"); } } + public static XLColor SapGreen => FromHtml("#FF507D2A"); - public static XLColor Sapphire { get { return FromHtml("#FF082567"); } } + public static XLColor Sapphire => FromHtml("#FF082567"); - public static XLColor SatinSheenGold { get { return FromHtml("#FFCBA135"); } } + public static XLColor SatinSheenGold => FromHtml("#FFCBA135"); - public static XLColor Scarlet { get { return FromHtml("#FFFF2000"); } } + public static XLColor Scarlet => FromHtml("#FFFF2000"); - public static XLColor SchoolBusYellow { get { return FromHtml("#FFFFD800"); } } + public static XLColor SchoolBusYellow => FromHtml("#FFFFD800"); - public static XLColor ScreaminGreen { get { return FromHtml("#FF76FF7A"); } } + public static XLColor ScreaminGreen => FromHtml("#FF76FF7A"); - public static XLColor SealBrown { get { return FromHtml("#FF321414"); } } + public static XLColor SealBrown => FromHtml("#FF321414"); - public static XLColor SelectiveYellow { get { return FromHtml("#FFFFBA00"); } } + public static XLColor SelectiveYellow => FromHtml("#FFFFBA00"); - public static XLColor Sepia { get { return FromHtml("#FF704214"); } } + public static XLColor Sepia => FromHtml("#FF704214"); - public static XLColor Shadow { get { return FromHtml("#FF8A795D"); } } + public static XLColor Shadow => FromHtml("#FF8A795D"); - public static XLColor ShamrockGreen { get { return FromHtml("#FF009E60"); } } + public static XLColor ShamrockGreen => FromHtml("#FF009E60"); - public static XLColor ShockingPink { get { return FromHtml("#FFFC0FC0"); } } + public static XLColor ShockingPink => FromHtml("#FFFC0FC0"); - public static XLColor Sienna1 { get { return FromHtml("#FF882D17"); } } + public static XLColor Sienna1 => FromHtml("#FF882D17"); - public static XLColor Sinopia { get { return FromHtml("#FFCB410B"); } } + public static XLColor Sinopia => FromHtml("#FFCB410B"); - public static XLColor Skobeloff { get { return FromHtml("#FF007474"); } } + public static XLColor Skobeloff => FromHtml("#FF007474"); - public static XLColor SkyMagenta { get { return FromHtml("#FFCF71AF"); } } + public static XLColor SkyMagenta => FromHtml("#FFCF71AF"); - public static XLColor SmaltDarkPowderBlue { get { return FromHtml("#FF003399"); } } + public static XLColor SmaltDarkPowderBlue => FromHtml("#FF003399"); - public static XLColor SmokeyTopaz { get { return FromHtml("#FF933D41"); } } + public static XLColor SmokeyTopaz => FromHtml("#FF933D41"); - public static XLColor SmokyBlack { get { return FromHtml("#FF100C08"); } } + public static XLColor SmokyBlack => FromHtml("#FF100C08"); - public static XLColor SpiroDiscoBall { get { return FromHtml("#FF0FC0FC"); } } + public static XLColor SpiroDiscoBall => FromHtml("#FF0FC0FC"); - public static XLColor SplashedWhite { get { return FromHtml("#FFFEFDFF"); } } + public static XLColor SplashedWhite => FromHtml("#FFFEFDFF"); - public static XLColor SpringBud { get { return FromHtml("#FFA7FC00"); } } + public static XLColor SpringBud => FromHtml("#FFA7FC00"); - public static XLColor StPatricksBlue { get { return FromHtml("#FF23297A"); } } + public static XLColor StPatricksBlue => FromHtml("#FF23297A"); - public static XLColor StilDeGrainYellow { get { return FromHtml("#FFFADA5E"); } } + public static XLColor StilDeGrainYellow => FromHtml("#FFFADA5E"); - public static XLColor Straw { get { return FromHtml("#FFE4D96F"); } } + public static XLColor Straw => FromHtml("#FFE4D96F"); - public static XLColor Sunglow { get { return FromHtml("#FFFFCC33"); } } + public static XLColor Sunglow => FromHtml("#FFFFCC33"); - public static XLColor Sunset { get { return FromHtml("#FFFAD6A5"); } } + public static XLColor Sunset => FromHtml("#FFFAD6A5"); - public static XLColor Tangelo { get { return FromHtml("#FFF94D00"); } } + public static XLColor Tangelo => FromHtml("#FFF94D00"); - public static XLColor Tangerine { get { return FromHtml("#FFF28500"); } } + public static XLColor Tangerine => FromHtml("#FFF28500"); - public static XLColor TangerineYellow { get { return FromHtml("#FFFFCC00"); } } + public static XLColor TangerineYellow => FromHtml("#FFFFCC00"); - public static XLColor Taupe { get { return FromHtml("#FF483C32"); } } + public static XLColor Taupe => FromHtml("#FF483C32"); - public static XLColor TaupeGray { get { return FromHtml("#FF8B8589"); } } + public static XLColor TaupeGray => FromHtml("#FF8B8589"); - public static XLColor TeaGreen { get { return FromHtml("#FFD0F0C0"); } } + public static XLColor TeaGreen => FromHtml("#FFD0F0C0"); - public static XLColor TealBlue { get { return FromHtml("#FF367588"); } } + public static XLColor TealBlue => FromHtml("#FF367588"); - public static XLColor TealGreen { get { return FromHtml("#FF006D5B"); } } + public static XLColor TealGreen => FromHtml("#FF006D5B"); - public static XLColor TeaRoseOrange { get { return FromHtml("#FFF88379"); } } + public static XLColor TeaRoseOrange => FromHtml("#FFF88379"); - public static XLColor TeaRoseRose { get { return FromHtml("#FFF4C2C2"); } } + public static XLColor TeaRoseRose => FromHtml("#FFF4C2C2"); - public static XLColor TennéTawny { get { return FromHtml("#FFCD5700"); } } + public static XLColor TennéTawny => FromHtml("#FFCD5700"); - public static XLColor TerraCotta { get { return FromHtml("#FFE2725B"); } } + public static XLColor TerraCotta => FromHtml("#FFE2725B"); - public static XLColor ThulianPink { get { return FromHtml("#FFDE6FA1"); } } + public static XLColor ThulianPink => FromHtml("#FFDE6FA1"); - public static XLColor TickleMePink { get { return FromHtml("#FFFC89AC"); } } + public static XLColor TickleMePink => FromHtml("#FFFC89AC"); - public static XLColor TiffanyBlue { get { return FromHtml("#FF0ABAB5"); } } + public static XLColor TiffanyBlue => FromHtml("#FF0ABAB5"); - public static XLColor TigersEye { get { return FromHtml("#FFE08D3C"); } } + public static XLColor TigersEye => FromHtml("#FFE08D3C"); - public static XLColor Timberwolf { get { return FromHtml("#FFDBD7D2"); } } + public static XLColor Timberwolf => FromHtml("#FFDBD7D2"); - public static XLColor TitaniumYellow { get { return FromHtml("#FFEEE600"); } } + public static XLColor TitaniumYellow => FromHtml("#FFEEE600"); - public static XLColor Toolbox { get { return FromHtml("#FF746CC0"); } } + public static XLColor Toolbox => FromHtml("#FF746CC0"); - public static XLColor TractorRed { get { return FromHtml("#FFFD0E35"); } } + public static XLColor TractorRed => FromHtml("#FFFD0E35"); - public static XLColor TropicalRainForest { get { return FromHtml("#FF00755E"); } } + public static XLColor TropicalRainForest => FromHtml("#FF00755E"); - public static XLColor TuftsBlue { get { return FromHtml("#FF417DC1"); } } + public static XLColor TuftsBlue => FromHtml("#FF417DC1"); - public static XLColor Tumbleweed { get { return FromHtml("#FFDEAA88"); } } + public static XLColor Tumbleweed => FromHtml("#FFDEAA88"); - public static XLColor TurkishRose { get { return FromHtml("#FFB57281"); } } + public static XLColor TurkishRose => FromHtml("#FFB57281"); - public static XLColor Turquoise1 { get { return FromHtml("#FF30D5C8"); } } + public static XLColor Turquoise1 => FromHtml("#FF30D5C8"); - public static XLColor TurquoiseBlue { get { return FromHtml("#FF00FFEF"); } } + public static XLColor TurquoiseBlue => FromHtml("#FF00FFEF"); - public static XLColor TurquoiseGreen { get { return FromHtml("#FFA0D6B4"); } } + public static XLColor TurquoiseGreen => FromHtml("#FFA0D6B4"); - public static XLColor TuscanRed { get { return FromHtml("#FF823535"); } } + public static XLColor TuscanRed => FromHtml("#FF823535"); - public static XLColor TwilightLavender { get { return FromHtml("#FF8A496B"); } } + public static XLColor TwilightLavender => FromHtml("#FF8A496B"); - public static XLColor TyrianPurple { get { return FromHtml("#FF66023C"); } } + public static XLColor TyrianPurple => FromHtml("#FF66023C"); - public static XLColor UaBlue { get { return FromHtml("#FF0033AA"); } } + public static XLColor UaBlue => FromHtml("#FF0033AA"); - public static XLColor UaRed { get { return FromHtml("#FFD9004C"); } } + public static XLColor UaRed => FromHtml("#FFD9004C"); - public static XLColor Ube { get { return FromHtml("#FF8878C3"); } } + public static XLColor Ube => FromHtml("#FF8878C3"); - public static XLColor UclaBlue { get { return FromHtml("#FF536895"); } } + public static XLColor UclaBlue => FromHtml("#FF536895"); - public static XLColor UclaGold { get { return FromHtml("#FFFFB300"); } } + public static XLColor UclaGold => FromHtml("#FFFFB300"); - public static XLColor UfoGreen { get { return FromHtml("#FF3CD070"); } } + public static XLColor UfoGreen => FromHtml("#FF3CD070"); - public static XLColor Ultramarine { get { return FromHtml("#FF120A8F"); } } + public static XLColor Ultramarine => FromHtml("#FF120A8F"); - public static XLColor UltramarineBlue { get { return FromHtml("#FF4166F5"); } } + public static XLColor UltramarineBlue => FromHtml("#FF4166F5"); - public static XLColor UltraPink { get { return FromHtml("#FFFF6FFF"); } } + public static XLColor UltraPink => FromHtml("#FFFF6FFF"); - public static XLColor Umber { get { return FromHtml("#FF635147"); } } + public static XLColor Umber => FromHtml("#FF635147"); - public static XLColor UnitedNationsBlue { get { return FromHtml("#FF5B92E5"); } } + public static XLColor UnitedNationsBlue => FromHtml("#FF5B92E5"); - public static XLColor UnmellowYellow { get { return FromHtml("#FFFFFF66"); } } + public static XLColor UnmellowYellow => FromHtml("#FFFFFF66"); - public static XLColor UpForestGreen { get { return FromHtml("#FF014421"); } } + public static XLColor UpForestGreen => FromHtml("#FF014421"); - public static XLColor UpMaroon { get { return FromHtml("#FF7B1113"); } } + public static XLColor UpMaroon => FromHtml("#FF7B1113"); - public static XLColor UpsdellRed { get { return FromHtml("#FFAE2029"); } } + public static XLColor UpsdellRed => FromHtml("#FFAE2029"); - public static XLColor Urobilin { get { return FromHtml("#FFE1AD21"); } } + public static XLColor Urobilin => FromHtml("#FFE1AD21"); - public static XLColor UscCardinal { get { return FromHtml("#FF990000"); } } + public static XLColor UscCardinal => FromHtml("#FF990000"); - public static XLColor UscGold { get { return FromHtml("#FFFFCC00"); } } + public static XLColor UscGold => FromHtml("#FFFFCC00"); - public static XLColor UtahCrimson { get { return FromHtml("#FFD3003F"); } } + public static XLColor UtahCrimson => FromHtml("#FFD3003F"); - public static XLColor Vanilla { get { return FromHtml("#FFF3E5AB"); } } + public static XLColor Vanilla => FromHtml("#FFF3E5AB"); - public static XLColor VegasGold { get { return FromHtml("#FFC5B358"); } } + public static XLColor VegasGold => FromHtml("#FFC5B358"); - public static XLColor VenetianRed { get { return FromHtml("#FFC80815"); } } + public static XLColor VenetianRed => FromHtml("#FFC80815"); - public static XLColor Verdigris { get { return FromHtml("#FF43B3AE"); } } + public static XLColor Verdigris => FromHtml("#FF43B3AE"); - public static XLColor Vermilion { get { return FromHtml("#FFE34234"); } } + public static XLColor Vermilion => FromHtml("#FFE34234"); - public static XLColor Veronica { get { return FromHtml("#FFA020F0"); } } + public static XLColor Veronica => FromHtml("#FFA020F0"); - public static XLColor Violet1 { get { return FromHtml("#FF8F00FF"); } } + public static XLColor Violet1 => FromHtml("#FF8F00FF"); - public static XLColor VioletColorWheel { get { return FromHtml("#FF7F00FF"); } } + public static XLColor VioletColorWheel => FromHtml("#FF7F00FF"); - public static XLColor VioletRyb { get { return FromHtml("#FF8601AF"); } } + public static XLColor VioletRyb => FromHtml("#FF8601AF"); - public static XLColor Viridian { get { return FromHtml("#FF40826D"); } } + public static XLColor Viridian => FromHtml("#FF40826D"); - public static XLColor VividAuburn { get { return FromHtml("#FF922724"); } } + public static XLColor VividAuburn => FromHtml("#FF922724"); - public static XLColor VividBurgundy { get { return FromHtml("#FF9F1D35"); } } + public static XLColor VividBurgundy => FromHtml("#FF9F1D35"); - public static XLColor VividCerise { get { return FromHtml("#FFDA1D81"); } } + public static XLColor VividCerise => FromHtml("#FFDA1D81"); - public static XLColor VividTangerine { get { return FromHtml("#FFFFA089"); } } + public static XLColor VividTangerine => FromHtml("#FFFFA089"); - public static XLColor VividViolet { get { return FromHtml("#FF9F00FF"); } } + public static XLColor VividViolet => FromHtml("#FF9F00FF"); - public static XLColor WarmBlack { get { return FromHtml("#FF004242"); } } + public static XLColor WarmBlack => FromHtml("#FF004242"); - public static XLColor Wenge { get { return FromHtml("#FF645452"); } } + public static XLColor Wenge => FromHtml("#FF645452"); - public static XLColor WildBlueYonder { get { return FromHtml("#FFA2ADD0"); } } + public static XLColor WildBlueYonder => FromHtml("#FFA2ADD0"); - public static XLColor WildStrawberry { get { return FromHtml("#FFFF43A4"); } } + public static XLColor WildStrawberry => FromHtml("#FFFF43A4"); - public static XLColor WildWatermelon { get { return FromHtml("#FFFC6C85"); } } + public static XLColor WildWatermelon => FromHtml("#FFFC6C85"); - public static XLColor Wisteria { get { return FromHtml("#FFC9A0DC"); } } + public static XLColor Wisteria => FromHtml("#FFC9A0DC"); - public static XLColor Xanadu { get { return FromHtml("#FF738678"); } } + public static XLColor Xanadu => FromHtml("#FF738678"); - public static XLColor YaleBlue { get { return FromHtml("#FF0F4D92"); } } + public static XLColor YaleBlue => FromHtml("#FF0F4D92"); - public static XLColor YellowMunsell { get { return FromHtml("#FFEFCC00"); } } + public static XLColor YellowMunsell => FromHtml("#FFEFCC00"); - public static XLColor YellowNcs { get { return FromHtml("#FFFFD300"); } } + public static XLColor YellowNcs => FromHtml("#FFFFD300"); - public static XLColor YellowProcess { get { return FromHtml("#FFFFEF00"); } } + public static XLColor YellowProcess => FromHtml("#FFFFEF00"); - public static XLColor YellowRyb { get { return FromHtml("#FFFEFE33"); } } + public static XLColor YellowRyb => FromHtml("#FFFEFE33"); - public static XLColor Zaffre { get { return FromHtml("#FF0014A8"); } } + public static XLColor Zaffre => FromHtml("#FF0014A8"); - public static XLColor ZinnwalditeBrown { get { return FromHtml("#FF2C1608"); } } + public static XLColor ZinnwalditeBrown => FromHtml("#FF2C1608"); - public static XLColor Transparent { get { return FromColor(Color.Transparent); } } + public static XLColor Transparent => FromColor(SKColors.Transparent); } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Style/IXLAlignment.cs b/ClosedXML/Excel/Style/IXLAlignment.cs index 61a330161..31399e567 100644 --- a/ClosedXML/Excel/Style/IXLAlignment.cs +++ b/ClosedXML/Excel/Style/IXLAlignment.cs @@ -45,12 +45,12 @@ public interface IXLAlignment : IEquatable /// /// Gets or sets the cell's text indentation. /// - Int32 Indent { get; set; } + int Indent { get; set; } /// /// Gets or sets whether the cell's last line is justified or not. /// - Boolean JustifyLastLine { get; set; } + bool JustifyLastLine { get; set; } /// /// Gets or sets the cell's reading order. @@ -60,47 +60,47 @@ public interface IXLAlignment : IEquatable /// /// Gets or sets the cell's relative indent. /// - Int32 RelativeIndent { get; set; } + int RelativeIndent { get; set; } /// /// Gets or sets whether the cell's font size should decrease to fit the contents. /// - Boolean ShrinkToFit { get; set; } + bool ShrinkToFit { get; set; } /// /// Gets or sets the cell's text rotation. /// - Int32 TextRotation { get; set; } + int TextRotation { get; set; } /// /// Gets or sets whether the cell's text should wrap if it doesn't fit. /// - Boolean WrapText { get; set; } + bool WrapText { get; set; } /// /// Gets or sets wheter the cell's text should be displayed from to to bottom /// (as opposed to the normal left to right). /// - Boolean TopToBottom { get; set; } + bool TopToBottom { get; set; } IXLStyle SetHorizontal(XLAlignmentHorizontalValues value); IXLStyle SetVertical(XLAlignmentVerticalValues value); - IXLStyle SetIndent(Int32 value); + IXLStyle SetIndent(int value); - IXLStyle SetJustifyLastLine(); IXLStyle SetJustifyLastLine(Boolean value); + IXLStyle SetJustifyLastLine(); IXLStyle SetJustifyLastLine(bool value); IXLStyle SetReadingOrder(XLAlignmentReadingOrderValues value); - IXLStyle SetRelativeIndent(Int32 value); + IXLStyle SetRelativeIndent(int value); - IXLStyle SetShrinkToFit(); IXLStyle SetShrinkToFit(Boolean value); + IXLStyle SetShrinkToFit(); IXLStyle SetShrinkToFit(bool value); - IXLStyle SetTextRotation(Int32 value); + IXLStyle SetTextRotation(int value); - IXLStyle SetWrapText(); IXLStyle SetWrapText(Boolean value); + IXLStyle SetWrapText(); IXLStyle SetWrapText(bool value); - IXLStyle SetTopToBottom(); IXLStyle SetTopToBottom(Boolean value); + IXLStyle SetTopToBottom(); IXLStyle SetTopToBottom(bool value); } } diff --git a/ClosedXML/Excel/Style/IXLBorder.cs b/ClosedXML/Excel/Style/IXLBorder.cs index 5c49df4c8..017a4c97e 100644 --- a/ClosedXML/Excel/Style/IXLBorder.cs +++ b/ClosedXML/Excel/Style/IXLBorder.cs @@ -46,9 +46,9 @@ public interface IXLBorder : IEquatable XLColor BottomBorderColor { get; set; } - Boolean DiagonalUp { get; set; } + bool DiagonalUp { get; set; } - Boolean DiagonalDown { get; set; } + bool DiagonalDown { get; set; } XLBorderStyleValues DiagonalBorder { get; set; } @@ -78,9 +78,9 @@ public interface IXLBorder : IEquatable IXLStyle SetBottomBorderColor(XLColor value); - IXLStyle SetDiagonalUp(); IXLStyle SetDiagonalUp(Boolean value); + IXLStyle SetDiagonalUp(); IXLStyle SetDiagonalUp(bool value); - IXLStyle SetDiagonalDown(); IXLStyle SetDiagonalDown(Boolean value); + IXLStyle SetDiagonalDown(); IXLStyle SetDiagonalDown(bool value); IXLStyle SetDiagonalBorder(XLBorderStyleValues value); diff --git a/ClosedXML/Excel/Style/IXLFont.cs b/ClosedXML/Excel/Style/IXLFont.cs index a996b6215..e501608a7 100644 --- a/ClosedXML/Excel/Style/IXLFont.cs +++ b/ClosedXML/Excel/Style/IXLFont.cs @@ -133,23 +133,23 @@ public enum XLFontCharSet public interface IXLFont : IXLFontBase, IEquatable { - IXLStyle SetBold(); IXLStyle SetBold(Boolean value); + IXLStyle SetBold(); IXLStyle SetBold(bool value); - IXLStyle SetItalic(); IXLStyle SetItalic(Boolean value); + IXLStyle SetItalic(); IXLStyle SetItalic(bool value); IXLStyle SetUnderline(); IXLStyle SetUnderline(XLFontUnderlineValues value); - IXLStyle SetStrikethrough(); IXLStyle SetStrikethrough(Boolean value); + IXLStyle SetStrikethrough(); IXLStyle SetStrikethrough(bool value); IXLStyle SetVerticalAlignment(XLFontVerticalTextAlignmentValues value); - IXLStyle SetShadow(); IXLStyle SetShadow(Boolean value); + IXLStyle SetShadow(); IXLStyle SetShadow(bool value); - IXLStyle SetFontSize(Double value); + IXLStyle SetFontSize(double value); IXLStyle SetFontColor(XLColor value); - IXLStyle SetFontName(String value); + IXLStyle SetFontName(string value); IXLStyle SetFontFamilyNumbering(XLFontFamilyNumberingValues value); diff --git a/ClosedXML/Excel/Style/IXLFontBase.cs b/ClosedXML/Excel/Style/IXLFontBase.cs index 21b8288a2..657921a4a 100644 --- a/ClosedXML/Excel/Style/IXLFontBase.cs +++ b/ClosedXML/Excel/Style/IXLFontBase.cs @@ -1,26 +1,24 @@ -using System; - namespace ClosedXML.Excel { public interface IXLFontBase { - Boolean Bold { get; set; } + bool Bold { get; set; } - Boolean Italic { get; set; } + bool Italic { get; set; } XLFontUnderlineValues Underline { get; set; } - Boolean Strikethrough { get; set; } + bool Strikethrough { get; set; } XLFontVerticalTextAlignmentValues VerticalAlignment { get; set; } - Boolean Shadow { get; set; } + bool Shadow { get; set; } - Double FontSize { get; set; } + double FontSize { get; set; } XLColor FontColor { get; set; } - String FontName { get; set; } + string FontName { get; set; } XLFontFamilyNumberingValues FontFamilyNumbering { get; set; } diff --git a/ClosedXML/Excel/Style/IXLNumberFormat.cs b/ClosedXML/Excel/Style/IXLNumberFormat.cs index cb55e5131..a909a9658 100644 --- a/ClosedXML/Excel/Style/IXLNumberFormat.cs +++ b/ClosedXML/Excel/Style/IXLNumberFormat.cs @@ -4,8 +4,8 @@ namespace ClosedXML.Excel { public interface IXLNumberFormat : IXLNumberFormatBase, IEquatable { - IXLStyle SetNumberFormatId(Int32 value); + IXLStyle SetNumberFormatId(int value); - IXLStyle SetFormat(String value); + IXLStyle SetFormat(string value); } } diff --git a/ClosedXML/Excel/Style/IXLNumberFormatBase.cs b/ClosedXML/Excel/Style/IXLNumberFormatBase.cs index d334a932d..88cefd397 100644 --- a/ClosedXML/Excel/Style/IXLNumberFormatBase.cs +++ b/ClosedXML/Excel/Style/IXLNumberFormatBase.cs @@ -1,11 +1,9 @@ -using System; - namespace ClosedXML.Excel { public interface IXLNumberFormatBase { - Int32 NumberFormatId { get; set; } + int NumberFormatId { get; set; } - String Format { get; set; } + string Format { get; set; } } } diff --git a/ClosedXML/Excel/Style/IXLProtection.cs b/ClosedXML/Excel/Style/IXLProtection.cs index 94d9153f6..087ef8728 100644 --- a/ClosedXML/Excel/Style/IXLProtection.cs +++ b/ClosedXML/Excel/Style/IXLProtection.cs @@ -4,12 +4,12 @@ namespace ClosedXML.Excel { public interface IXLProtection : IEquatable { - Boolean Locked { get; set; } + bool Locked { get; set; } - Boolean Hidden { get; set; } + bool Hidden { get; set; } - IXLStyle SetLocked(); IXLStyle SetLocked(Boolean value); + IXLStyle SetLocked(); IXLStyle SetLocked(bool value); - IXLStyle SetHidden(); IXLStyle SetHidden(Boolean value); + IXLStyle SetHidden(); IXLStyle SetHidden(bool value); } } diff --git a/ClosedXML/Excel/Style/IXLStyle.cs b/ClosedXML/Excel/Style/IXLStyle.cs index 7634e61df..38cd696c1 100644 --- a/ClosedXML/Excel/Style/IXLStyle.cs +++ b/ClosedXML/Excel/Style/IXLStyle.cs @@ -15,12 +15,12 @@ public interface IXLStyle : IEquatable IXLFont Font { get; set; } - Boolean IncludeQuotePrefix { get; set; } + bool IncludeQuotePrefix { get; set; } IXLNumberFormat NumberFormat { get; set; } IXLProtection Protection { get; set; } - IXLStyle SetIncludeQuotePrefix(Boolean includeQuotePrefix = true); + IXLStyle SetIncludeQuotePrefix(bool includeQuotePrefix = true); } } diff --git a/ClosedXML/Excel/Style/XLAlignment.cs b/ClosedXML/Excel/Style/XLAlignment.cs index 36057767b..4524d21ff 100644 --- a/ClosedXML/Excel/Style/XLAlignment.cs +++ b/ClosedXML/Excel/Style/XLAlignment.cs @@ -85,7 +85,7 @@ public XLAlignmentHorizontalValues Horizontal get { return Key.Horizontal; } set { - Boolean updateIndent = !( + var updateIndent = !( value == XLAlignmentHorizontalValues.Left || value == XLAlignmentHorizontalValues.Right || value == XLAlignmentHorizontalValues.Distributed @@ -93,7 +93,9 @@ public XLAlignmentHorizontalValues Horizontal Modify(k => { k.Horizontal = value; return k; }); if (updateIndent) + { Indent = 0; + } } } @@ -103,7 +105,7 @@ public XLAlignmentVerticalValues Vertical set { Modify(k => { k.Vertical = value; return k; }); } } - public Int32 Indent + public int Indent { get { return Key.Indent; } set @@ -111,7 +113,9 @@ public Int32 Indent if (Indent != value) { if (Horizontal == XLAlignmentHorizontalValues.General) + { Horizontal = XLAlignmentHorizontalValues.Left; + } if (value > 0 && !( Horizontal == XLAlignmentHorizontalValues.Left @@ -127,7 +131,7 @@ public Int32 Indent } } - public Boolean JustifyLastLine + public bool JustifyLastLine { get { return Key.JustifyLastLine; } set { Modify(k => { k.JustifyLastLine = value; return k; }); } @@ -139,39 +143,41 @@ public XLAlignmentReadingOrderValues ReadingOrder set { Modify(k => { k.ReadingOrder = value; return k; }); } } - public Int32 RelativeIndent + public int RelativeIndent { get { return Key.RelativeIndent; } set { Modify(k => { k.RelativeIndent = value; return k; }); } } - public Boolean ShrinkToFit + public bool ShrinkToFit { get { return Key.ShrinkToFit; } set { Modify(k => { k.ShrinkToFit = value; return k; }); } } - public Int32 TextRotation + public int TextRotation { get { return Key.TextRotation; } set { - Int32 rotation = value; + var rotation = value; if (rotation != 255 && (rotation < -90 || rotation > 180)) + { throw new ArgumentException("TextRotation must be between -90 and 180 degrees, or 255."); + } Modify(k => { k.TextRotation = rotation; return k; }); } } - public Boolean WrapText + public bool WrapText { get { return Key.WrapText; } set { Modify(k => { k.WrapText = value; return k; }); } } - public Boolean TopToBottom + public bool TopToBottom { get { return TextRotation == 255; } set { TextRotation = value ? 255 : 0; } @@ -189,7 +195,7 @@ public IXLStyle SetVertical(XLAlignmentVerticalValues value) return _style; } - public IXLStyle SetIndent(Int32 value) + public IXLStyle SetIndent(int value) { Indent = value; return _style; @@ -201,7 +207,7 @@ public IXLStyle SetJustifyLastLine() return _style; } - public IXLStyle SetJustifyLastLine(Boolean value) + public IXLStyle SetJustifyLastLine(bool value) { JustifyLastLine = value; return _style; @@ -213,7 +219,7 @@ public IXLStyle SetReadingOrder(XLAlignmentReadingOrderValues value) return _style; } - public IXLStyle SetRelativeIndent(Int32 value) + public IXLStyle SetRelativeIndent(int value) { RelativeIndent = value; return _style; @@ -225,13 +231,13 @@ public IXLStyle SetShrinkToFit() return _style; } - public IXLStyle SetShrinkToFit(Boolean value) + public IXLStyle SetShrinkToFit(bool value) { ShrinkToFit = value; return _style; } - public IXLStyle SetTextRotation(Int32 value) + public IXLStyle SetTextRotation(int value) { TextRotation = value; return _style; @@ -243,7 +249,7 @@ public IXLStyle SetWrapText() return _style; } - public IXLStyle SetWrapText(Boolean value) + public IXLStyle SetWrapText(bool value) { WrapText = value; return _style; @@ -255,7 +261,7 @@ public IXLStyle SetTopToBottom() return _style; } - public IXLStyle SetTopToBottom(Boolean value) + public IXLStyle SetTopToBottom(bool value) { TopToBottom = value; return _style; @@ -308,9 +314,10 @@ public override bool Equals(object obj) public bool Equals(IXLAlignment other) { - var otherA = other as XLAlignment; - if (otherA == null) + if (!(other is XLAlignment otherA)) + { return false; + } return Key == otherA.Key; } diff --git a/ClosedXML/Excel/Style/XLAlignmentKey.cs b/ClosedXML/Excel/Style/XLAlignmentKey.cs index c16722420..eebbf2df8 100644 --- a/ClosedXML/Excel/Style/XLAlignmentKey.cs +++ b/ClosedXML/Excel/Style/XLAlignmentKey.cs @@ -42,7 +42,10 @@ public bool Equals(XLAlignmentKey other) public override bool Equals(object obj) { if (obj is XLAlignment) + { return Equals((XLAlignment)obj); + } + return base.Equals(obj); } @@ -73,6 +76,6 @@ public override string ToString() public static bool operator ==(XLAlignmentKey left, XLAlignmentKey right) => left.Equals(right); - public static bool operator !=(XLAlignmentKey left, XLAlignmentKey right) => !(left.Equals(right)); + public static bool operator !=(XLAlignmentKey left, XLAlignmentKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLAlignmentValue.cs b/ClosedXML/Excel/Style/XLAlignmentValue.cs index 758f0acbf..3ce3bb8f4 100644 --- a/ClosedXML/Excel/Style/XLAlignmentValue.cs +++ b/ClosedXML/Excel/Style/XLAlignmentValue.cs @@ -28,25 +28,25 @@ public static XLAlignmentValue FromKey(ref XLAlignmentKey key) public XLAlignmentKey Key { get; private set; } - public XLAlignmentHorizontalValues Horizontal { get { return Key.Horizontal; } } + public XLAlignmentHorizontalValues Horizontal => Key.Horizontal; - public XLAlignmentVerticalValues Vertical { get { return Key.Vertical; } } + public XLAlignmentVerticalValues Vertical => Key.Vertical; - public int Indent { get { return Key.Indent; } } + public int Indent => Key.Indent; - public bool JustifyLastLine { get { return Key.JustifyLastLine; } } + public bool JustifyLastLine => Key.JustifyLastLine; - public XLAlignmentReadingOrderValues ReadingOrder { get { return Key.ReadingOrder; } } + public XLAlignmentReadingOrderValues ReadingOrder => Key.ReadingOrder; - public int RelativeIndent { get { return Key.RelativeIndent; } } + public int RelativeIndent => Key.RelativeIndent; - public bool ShrinkToFit { get { return Key.ShrinkToFit; } } + public bool ShrinkToFit => Key.ShrinkToFit; - public int TextRotation { get { return Key.TextRotation; } } + public int TextRotation => Key.TextRotation; - public bool WrapText { get { return Key.WrapText; } } + public bool WrapText => Key.WrapText; - public bool TopToBottom { get { return Key.TopToBottom; } } + public bool TopToBottom => Key.TopToBottom; private XLAlignmentValue(XLAlignmentKey key) { @@ -55,8 +55,7 @@ private XLAlignmentValue(XLAlignmentKey key) public override bool Equals(object obj) { - var cached = obj as XLAlignmentValue; - return cached != null && + return obj is XLAlignmentValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLBorder.cs b/ClosedXML/Excel/Style/XLBorder.cs index a85602710..c9ebd6814 100644 --- a/ClosedXML/Excel/Style/XLBorder.cs +++ b/ClosedXML/Excel/Style/XLBorder.cs @@ -86,7 +86,10 @@ public XLBorderStyleValues OutsideBorder { set { - if (_container == null) return; + if (_container == null) + { + return; + } if (_container is XLWorksheet || _container is XLConditionalFormat) { @@ -101,7 +104,7 @@ public XLBorderStyleValues OutsideBorder } else { - foreach (IXLRange r in _container.RangesUsed) + foreach (var r in _container.RangesUsed) { r.FirstColumn().Style.Border.LeftBorder = value; r.LastColumn().Style.Border.RightBorder = value; @@ -116,7 +119,10 @@ public XLColor OutsideBorderColor { set { - if (_container == null) return; + if (_container == null) + { + return; + } if (_container is XLWorksheet || _container is XLConditionalFormat) { @@ -131,7 +137,7 @@ public XLColor OutsideBorderColor } else { - foreach (IXLRange r in _container.RangesUsed) + foreach (var r in _container.RangesUsed) { r.FirstColumn().Style.Border.LeftBorderColor = value; r.LastColumn().Style.Border.RightBorderColor = value; @@ -146,10 +152,12 @@ public XLBorderStyleValues InsideBorder { set { - if (_container == null) return; + if (_container == null) + { + return; + } - var wsContainer = _container as XLWorksheet; - if (wsContainer != null) + if (_container is XLWorksheet wsContainer) { Modify(k => { @@ -162,7 +170,7 @@ public XLBorderStyleValues InsideBorder } else { - foreach (IXLRange r in _container.RangesUsed) + foreach (var r in _container.RangesUsed) { using (new RestoreOutsideBorder(r)) { @@ -188,10 +196,12 @@ public XLColor InsideBorderColor { set { - if (_container == null) return; + if (_container == null) + { + return; + } - var wsContainer = _container as XLWorksheet; - if (wsContainer != null) + if (_container is XLWorksheet wsContainer) { Modify(k => { @@ -204,7 +214,7 @@ public XLColor InsideBorderColor } else { - foreach (IXLRange r in _container.RangesUsed) + foreach (var r in _container.RangesUsed) { using (new RestoreOutsideBorder(r)) { @@ -242,7 +252,9 @@ public XLColor LeftBorderColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.LeftBorderColor = value.Key; return k; }); } @@ -264,7 +276,9 @@ public XLColor RightBorderColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.RightBorderColor = value.Key; return k; }); } @@ -286,7 +300,9 @@ public XLColor TopBorderColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.TopBorderColor = value.Key; return k; }); } @@ -308,7 +324,9 @@ public XLColor BottomBorderColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.BottomBorderColor = value.Key; return k; }); } @@ -330,19 +348,21 @@ public XLColor DiagonalBorderColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.DiagonalBorderColor = value.Key; return k; }); } } - public Boolean DiagonalUp + public bool DiagonalUp { get { return Key.DiagonalUp; } set { Modify(k => { k.DiagonalUp = value; return k; }); } } - public Boolean DiagonalDown + public bool DiagonalDown { get { return Key.DiagonalDown; } set { Modify(k => { k.DiagonalDown = value; return k; }); } @@ -426,7 +446,7 @@ public IXLStyle SetDiagonalUp() return _container.Style; } - public IXLStyle SetDiagonalUp(Boolean value) + public IXLStyle SetDiagonalUp(bool value) { DiagonalUp = value; return _container.Style; @@ -438,7 +458,7 @@ public IXLStyle SetDiagonalDown() return _container.Style; } - public IXLStyle SetDiagonalDown(Boolean value) + public IXLStyle SetDiagonalDown(bool value) { DiagonalDown = value; return _container.Style; @@ -508,9 +528,10 @@ public override bool Equals(object obj) public bool Equals(IXLBorder other) { - var otherB = other as XLBorder; - if (otherB == null) + if (!(other is XLBorder otherB)) + { return false; + } return Key == otherB.Key; } @@ -530,6 +551,8 @@ public override int GetHashCode() /// private class RestoreOutsideBorder : IDisposable { + private bool _disposed; + private readonly IXLRange _range; private readonly Dictionary _topBorders; private readonly Dictionary _bottomBorders; @@ -557,55 +580,55 @@ public RestoreOutsideBorder(IXLRange range) c => (c.Style as XLStyle).Key.Border); } - // Used by Janitor.Fody - private void DisposeManaged() + public void Dispose() { - _topBorders.ForEach(kp => (_range.FirstRow().Cell(kp.Key).Style - .Border as XLBorder).Modify(k => - { - k.TopBorder = kp.Value.TopBorder; - k.TopBorderColor = kp.Value.TopBorderColor; - return k; - })); - _bottomBorders.ForEach(kp => (_range.LastRow().Cell(kp.Key).Style - .Border as XLBorder).Modify(k => - { - k.BottomBorder = kp.Value.BottomBorder; - k.BottomBorderColor = kp.Value.BottomBorderColor; - return k; - })); - _leftBorders.ForEach(kp => (_range.FirstColumn().Cell(kp.Key).Style - .Border as XLBorder).Modify(k => - { - k.LeftBorder = kp.Value.LeftBorder; - k.LeftBorderColor = kp.Value.LeftBorderColor; - return k; - })); - _rightBorders.ForEach(kp => (_range.LastColumn().Cell(kp.Key).Style - .Border as XLBorder).Modify(k => - { - k.RightBorder = kp.Value.RightBorder; - k.RightBorderColor = kp.Value.RightBorderColor; - return k; - })); + // Dispose of unmanaged resources. + Dispose(true); + // Suppress finalization. + GC.SuppressFinalize(this); } -#if _NET40_ - - public void Dispose() + public void Dispose(bool disposing) { - // net40 doesn't support Janitor.Fody, so let's dispose manually - DisposeManaged(); - } + if (_disposed) + { + return; + } -#else + if (disposing) + { + _topBorders.ForEach(kp => (_range.FirstRow().Cell(kp.Key).Style + .Border as XLBorder).Modify(k => + { + k.TopBorder = kp.Value.TopBorder; + k.TopBorderColor = kp.Value.TopBorderColor; + return k; + })); + _bottomBorders.ForEach(kp => (_range.LastRow().Cell(kp.Key).Style + .Border as XLBorder).Modify(k => + { + k.BottomBorder = kp.Value.BottomBorder; + k.BottomBorderColor = kp.Value.BottomBorderColor; + return k; + })); + _leftBorders.ForEach(kp => (_range.FirstColumn().Cell(kp.Key).Style + .Border as XLBorder).Modify(k => + { + k.LeftBorder = kp.Value.LeftBorder; + k.LeftBorderColor = kp.Value.LeftBorderColor; + return k; + })); + _rightBorders.ForEach(kp => (_range.LastColumn().Cell(kp.Key).Style + .Border as XLBorder).Modify(k => + { + k.RightBorder = kp.Value.RightBorder; + k.RightBorderColor = kp.Value.RightBorderColor; + return k; + })); + } - public void Dispose() - { - // Leave this empty (for non net40 targets) so that Janitor.Fody can do its work + _disposed = true; } - -#endif } } } diff --git a/ClosedXML/Excel/Style/XLBorderKey.cs b/ClosedXML/Excel/Style/XLBorderKey.cs index facb097ec..5166db462 100644 --- a/ClosedXML/Excel/Style/XLBorderKey.cs +++ b/ClosedXML/Excel/Style/XLBorderKey.cs @@ -40,15 +40,29 @@ public override int GetHashCode() hashCode = hashCode * -1521134295 + DiagonalDown.GetHashCode(); if (LeftBorder != XLBorderStyleValues.None) + { hashCode = hashCode * -1521134295 + LeftBorderColor.GetHashCode(); + } + if (RightBorder != XLBorderStyleValues.None) + { hashCode = hashCode * -1521134295 + RightBorderColor.GetHashCode(); + } + if (TopBorder != XLBorderStyleValues.None) + { hashCode = hashCode * -1521134295 + TopBorderColor.GetHashCode(); + } + if (BottomBorder != XLBorderStyleValues.None) + { hashCode = hashCode * -1521134295 + BottomBorderColor.GetHashCode(); + } + if (DiagonalBorder != XLBorderStyleValues.None) + { hashCode = hashCode * -1521134295 + DiagonalBorderColor.GetHashCode(); + } return hashCode; } @@ -78,7 +92,10 @@ private bool AreEquivalent( public override bool Equals(object obj) { if (obj is XLBorderKey) + { return Equals((XLBorderKey)obj); + } + return base.Equals(obj); } @@ -92,6 +109,6 @@ public override string ToString() public static bool operator ==(XLBorderKey left, XLBorderKey right) => left.Equals(right); - public static bool operator !=(XLBorderKey left, XLBorderKey right) => !(left.Equals(right)); + public static bool operator !=(XLBorderKey left, XLBorderKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLBorderValue.cs b/ClosedXML/Excel/Style/XLBorderValue.cs index f5cfd6c32..1d431dc09 100644 --- a/ClosedXML/Excel/Style/XLBorderValue.cs +++ b/ClosedXML/Excel/Style/XLBorderValue.cs @@ -31,29 +31,29 @@ public static XLBorderValue FromKey(ref XLBorderKey key) public XLBorderKey Key { get; private set; } - public XLBorderStyleValues LeftBorder { get { return Key.LeftBorder; } } + public XLBorderStyleValues LeftBorder => Key.LeftBorder; public XLColor LeftBorderColor { get; private set; } - public XLBorderStyleValues RightBorder { get { return Key.RightBorder; } } + public XLBorderStyleValues RightBorder => Key.RightBorder; public XLColor RightBorderColor { get; private set; } - public XLBorderStyleValues TopBorder { get { return Key.TopBorder; } } + public XLBorderStyleValues TopBorder => Key.TopBorder; public XLColor TopBorderColor { get; private set; } - public XLBorderStyleValues BottomBorder { get { return Key.BottomBorder; } } + public XLBorderStyleValues BottomBorder => Key.BottomBorder; public XLColor BottomBorderColor { get; private set; } - public XLBorderStyleValues DiagonalBorder { get { return Key.DiagonalBorder; } } + public XLBorderStyleValues DiagonalBorder => Key.DiagonalBorder; public XLColor DiagonalBorderColor { get; private set; } - public bool DiagonalUp { get { return Key.DiagonalUp; } } + public bool DiagonalUp => Key.DiagonalUp; - public bool DiagonalDown { get { return Key.DiagonalDown; } } + public bool DiagonalDown => Key.DiagonalDown; private XLBorderValue(XLBorderKey key) { @@ -72,8 +72,7 @@ private XLBorderValue(XLBorderKey key) public override bool Equals(object obj) { - var cached = obj as XLBorderValue; - return cached != null && + return obj is XLBorderValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLColorKey.cs b/ClosedXML/Excel/Style/XLColorKey.cs index a30822bb4..ab60c1ce3 100644 --- a/ClosedXML/Excel/Style/XLColorKey.cs +++ b/ClosedXML/Excel/Style/XLColorKey.cs @@ -1,4 +1,5 @@ -using System; +using SkiaSharp; +using System; namespace ClosedXML.Excel { @@ -6,7 +7,7 @@ internal struct XLColorKey : IEquatable { public XLColorType ColorType { get; set; } - public System.Drawing.Color Color { get; set; } + public SKColor Color { get; set; } public int Indexed { get; set; } @@ -21,7 +22,7 @@ public override int GetHashCode() hashCode = hashCode * -1521134295 + (ColorType == XLColorType.Indexed ? Indexed : 0); hashCode = hashCode * -1521134295 + (ColorType == XLColorType.Theme ? (int)ThemeColor : 0); hashCode = hashCode * -1521134295 + (ColorType == XLColorType.Theme ? ThemeTint.GetHashCode() : 0); - hashCode = hashCode * -1521134295 + (ColorType == XLColorType.Color ? Color.ToArgb() : 0); + hashCode = hashCode * -1521134295 + (ColorType == XLColorType.Color ? Color.GetHashCode() : 0); return hashCode; } @@ -31,9 +32,7 @@ public bool Equals(XLColorKey other) { if (ColorType == XLColorType.Color) { - // .NET Color.Equals() will return false for Color.FromArgb(255, 255, 255, 255) == Color.White - // Therefore we compare the ToArgb() values - return Color.ToArgb() == other.Color.ToArgb(); + return Color.Alpha == other.Color.Alpha && Color.Red == other.Color.Red && Color.Green == other.Color.Green && Color.Blue == other.Color.Blue; } if (ColorType == XLColorType.Theme) { @@ -50,7 +49,10 @@ public bool Equals(XLColorKey other) public override bool Equals(object obj) { if (obj is XLColorKey) + { return Equals((XLColorKey)obj); + } + return base.Equals(obj); } @@ -60,10 +62,13 @@ public override string ToString() { case XLColorType.Color: return Color.ToString(); + case XLColorType.Theme: return $"{ThemeColor} ({ThemeTint})"; + case XLColorType.Indexed: return $"Indexed: {Indexed}"; + default: return base.ToString(); } @@ -71,6 +76,6 @@ public override string ToString() public static bool operator ==(XLColorKey left, XLColorKey right) => left.Equals(right); - public static bool operator !=(XLColorKey left, XLColorKey right) => !(left.Equals(right)); + public static bool operator !=(XLColorKey left, XLColorKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLFill.cs b/ClosedXML/Excel/Style/XLFill.cs index 0835fe543..bedd5cb03 100644 --- a/ClosedXML/Excel/Style/XLFill.cs +++ b/ClosedXML/Excel/Style/XLFill.cs @@ -1,5 +1,4 @@ using System; -using System.Linq; namespace ClosedXML.Excel { @@ -93,7 +92,9 @@ public XLColor BackgroundColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } if ((PatternType == XLFillPatternValues.None || PatternType == XLFillPatternValues.Solid) @@ -108,7 +109,9 @@ public XLColor BackgroundColor }); } else + { Modify(k => { k.BackgroundColor = value.Key; return k; }); + } } } @@ -122,7 +125,9 @@ public XLColor PatternColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } Modify(k => { k.PatternColor = value.Key; return k; }); } @@ -146,7 +151,9 @@ public XLFillPatternValues PatternType }); } else + { Modify(k => { k.PatternType = value; return k; }); + } } } @@ -179,9 +186,10 @@ public override bool Equals(object obj) public bool Equals(IXLFill other) { - var otherF = other as XLFill; - if (otherF == null) + if (!(other is XLFill otherF)) + { return false; + } return Key == otherF.Key; } diff --git a/ClosedXML/Excel/Style/XLFillKey.cs b/ClosedXML/Excel/Style/XLFillKey.cs index de1a2cfcd..e376098b9 100644 --- a/ClosedXML/Excel/Style/XLFillKey.cs +++ b/ClosedXML/Excel/Style/XLFillKey.cs @@ -14,13 +14,19 @@ public override int GetHashCode() { var hashCode = 2043579837; - if (HasNoFill()) return hashCode; + if (HasNoFill()) + { + return hashCode; + } hashCode = hashCode * -1521134295 + (int)PatternType; hashCode = hashCode * -1521134295 + BackgroundColor.GetHashCode(); - if (HasNoForeground()) return hashCode; - + if (HasNoForeground()) + { + return hashCode; + } + hashCode = hashCode * -1521134295 + PatternColor.GetHashCode(); return hashCode; @@ -29,7 +35,9 @@ public override int GetHashCode() public bool Equals(XLFillKey other) { if (HasNoFill() && other.HasNoFill()) + { return true; + } return BackgroundColor == other.BackgroundColor && PatternType == other.PatternType @@ -52,7 +60,10 @@ private bool HasNoForeground() public override bool Equals(object obj) { if (obj is XLFillKey) + { return Equals((XLFillKey)obj); + } + return base.Equals(obj); } @@ -63,6 +74,6 @@ public override string ToString() public static bool operator ==(XLFillKey left, XLFillKey right) => left.Equals(right); - public static bool operator !=(XLFillKey left, XLFillKey right) => !(left.Equals(right)); + public static bool operator !=(XLFillKey left, XLFillKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLFillValue.cs b/ClosedXML/Excel/Style/XLFillValue.cs index f7c2eb098..56e0471dc 100644 --- a/ClosedXML/Excel/Style/XLFillValue.cs +++ b/ClosedXML/Excel/Style/XLFillValue.cs @@ -26,7 +26,7 @@ public static XLFillValue FromKey(ref XLFillKey key) public XLColor PatternColor { get; private set; } - public XLFillPatternValues PatternType { get { return Key.PatternType; } } + public XLFillPatternValues PatternType => Key.PatternType; private XLFillValue(XLFillKey key) { @@ -39,8 +39,7 @@ private XLFillValue(XLFillKey key) public override bool Equals(object obj) { - var cached = obj as XLFillValue; - return cached != null && + return obj is XLFillValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLFont.cs b/ClosedXML/Excel/Style/XLFont.cs index 22a45d8d6..6d060f33c 100644 --- a/ClosedXML/Excel/Style/XLFont.cs +++ b/ClosedXML/Excel/Style/XLFont.cs @@ -101,7 +101,7 @@ private void Modify(Func modification) #region IXLFont Members - public Boolean Bold + public bool Bold { get { return Key.Bold; } set @@ -110,7 +110,7 @@ public Boolean Bold } } - public Boolean Italic + public bool Italic { get { return Key.Italic; } set @@ -128,7 +128,7 @@ public XLFontUnderlineValues Underline } } - public Boolean Strikethrough + public bool Strikethrough { get { return Key.Strikethrough; } set @@ -146,7 +146,7 @@ public XLFontVerticalTextAlignmentValues VerticalAlignment } } - public Boolean Shadow + public bool Shadow { get { return Key.Shadow; } set @@ -155,7 +155,7 @@ public Boolean Shadow } } - public Double FontSize + public double FontSize { get { return Key.FontSize; } set @@ -174,12 +174,15 @@ public XLColor FontColor set { if (value == null) + { throw new ArgumentNullException(nameof(value), "Color cannot be null"); + } + Modify(k => { k.FontColor = value.Key; return k; }); } } - public String FontName + public string FontName { get { return Key.FontName; } set @@ -212,7 +215,7 @@ public IXLStyle SetBold() return _style; } - public IXLStyle SetBold(Boolean value) + public IXLStyle SetBold(bool value) { Bold = value; return _style; @@ -224,7 +227,7 @@ public IXLStyle SetItalic() return _style; } - public IXLStyle SetItalic(Boolean value) + public IXLStyle SetItalic(bool value) { Italic = value; return _style; @@ -248,7 +251,7 @@ public IXLStyle SetStrikethrough() return _style; } - public IXLStyle SetStrikethrough(Boolean value) + public IXLStyle SetStrikethrough(bool value) { Strikethrough = value; return _style; @@ -266,13 +269,13 @@ public IXLStyle SetShadow() return _style; } - public IXLStyle SetShadow(Boolean value) + public IXLStyle SetShadow(bool value) { Shadow = value; return _style; } - public IXLStyle SetFontSize(Double value) + public IXLStyle SetFontSize(double value) { FontSize = value; return _style; @@ -284,7 +287,7 @@ public IXLStyle SetFontColor(XLColor value) return _style; } - public IXLStyle SetFontName(String value) + public IXLStyle SetFontName(string value) { FontName = value; return _style; @@ -336,11 +339,12 @@ public override bool Equals(object obj) return Equals(obj as XLFont); } - public Boolean Equals(IXLFont other) + public bool Equals(IXLFont other) { - var otherF = other as XLFont; - if (otherF == null) + if (!(other is XLFont otherF)) + { return false; + } return Key == otherF.Key; } diff --git a/ClosedXML/Excel/Style/XLFontKey.cs b/ClosedXML/Excel/Style/XLFontKey.cs index 1afbbf148..a8ad883d5 100644 --- a/ClosedXML/Excel/Style/XLFontKey.cs +++ b/ClosedXML/Excel/Style/XLFontKey.cs @@ -45,7 +45,10 @@ public bool Equals(XLFontKey other) public override bool Equals(object obj) { if (obj is XLFontKey) + { return Equals((XLFontKey)obj); + } + return base.Equals(obj); } @@ -76,6 +79,6 @@ public override string ToString() public static bool operator ==(XLFontKey left, XLFontKey right) => left.Equals(right); - public static bool operator !=(XLFontKey left, XLFontKey right) => !(left.Equals(right)); + public static bool operator !=(XLFontKey left, XLFontKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLFontValue.cs b/ClosedXML/Excel/Style/XLFontValue.cs index 37b4d7430..ef2ce4911 100644 --- a/ClosedXML/Excel/Style/XLFontValue.cs +++ b/ClosedXML/Excel/Style/XLFontValue.cs @@ -29,27 +29,27 @@ public static XLFontValue FromKey(ref XLFontKey key) public XLFontKey Key { get; private set; } - public bool Bold { get { return Key.Bold; } } + public bool Bold => Key.Bold; - public bool Italic { get { return Key.Italic; } } + public bool Italic => Key.Italic; - public XLFontUnderlineValues Underline { get { return Key.Underline; } } + public XLFontUnderlineValues Underline => Key.Underline; - public bool Strikethrough { get { return Key.Strikethrough; } } + public bool Strikethrough => Key.Strikethrough; - public XLFontVerticalTextAlignmentValues VerticalAlignment { get { return Key.VerticalAlignment; } } + public XLFontVerticalTextAlignmentValues VerticalAlignment => Key.VerticalAlignment; - public bool Shadow { get { return Key.Shadow; } } + public bool Shadow => Key.Shadow; - public double FontSize { get { return Key.FontSize; } } + public double FontSize => Key.FontSize; public XLColor FontColor { get; private set; } - public string FontName { get { return Key.FontName; } } + public string FontName => Key.FontName; - public XLFontFamilyNumberingValues FontFamilyNumbering { get { return Key.FontFamilyNumbering; } } + public XLFontFamilyNumberingValues FontFamilyNumbering => Key.FontFamilyNumbering; - public XLFontCharSet FontCharSet { get { return Key.FontCharSet; } } + public XLFontCharSet FontCharSet => Key.FontCharSet; private XLFontValue(XLFontKey key) { @@ -60,8 +60,7 @@ private XLFontValue(XLFontKey key) public override bool Equals(object obj) { - var cached = obj as XLFontValue; - return cached != null && + return obj is XLFontValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLNumberFormat.cs b/ClosedXML/Excel/Style/XLNumberFormat.cs index 54ffb778c..0f149c861 100644 --- a/ClosedXML/Excel/Style/XLNumberFormat.cs +++ b/ClosedXML/Excel/Style/XLNumberFormat.cs @@ -9,10 +9,14 @@ internal class XLNumberFormat : IXLNumberFormat internal static XLNumberFormatKey GenerateKey(IXLNumberFormat defaultNumberFormat) { if (defaultNumberFormat == null) + { return XLNumberFormatValue.Default.Key; + } if (defaultNumberFormat is XLNumberFormat) + { return (defaultNumberFormat as XLNumberFormat).Key; + } return new XLNumberFormatKey { @@ -62,7 +66,7 @@ public XLNumberFormat(XLStyle style = null, IXLNumberFormat d = null) : this(sty #region IXLNumberFormat Members - public Int32 NumberFormatId + public int NumberFormatId { get { return Key.NumberFormatId; } set @@ -76,7 +80,7 @@ public Int32 NumberFormatId } } - public String Format + public string Format { get { return Key.Format; } set @@ -85,21 +89,26 @@ public String Format { k.Format = value; if (string.IsNullOrWhiteSpace(k.Format)) + { k.NumberFormatId = XLNumberFormatValue.Default.NumberFormatId; + } else + { k.NumberFormatId = -1; + } + return k; }); } } - public IXLStyle SetNumberFormatId(Int32 value) + public IXLStyle SetNumberFormatId(int value) { NumberFormatId = value; return _style; } - public IXLStyle SetFormat(String value) + public IXLStyle SetFormat(string value) { Format = value; return _style; @@ -133,9 +142,10 @@ public override bool Equals(object obj) public bool Equals(IXLNumberFormatBase other) { - var otherN = other as XLNumberFormat; - if (otherN == null) + if (!(other is XLNumberFormat otherN)) + { return false; + } return Key == otherN.Key; } diff --git a/ClosedXML/Excel/Style/XLNumberFormatKey.cs b/ClosedXML/Excel/Style/XLNumberFormatKey.cs index 7e979a902..7c76154a9 100644 --- a/ClosedXML/Excel/Style/XLNumberFormatKey.cs +++ b/ClosedXML/Excel/Style/XLNumberFormatKey.cs @@ -26,7 +26,10 @@ public bool Equals(XLNumberFormatKey other) public override bool Equals(object obj) { if (obj is XLNumberFormatKey) + { return Equals((XLNumberFormatKey)obj); + } + return base.Equals(obj); } @@ -37,6 +40,6 @@ public override string ToString() public static bool operator ==(XLNumberFormatKey left, XLNumberFormatKey right) => left.Equals(right); - public static bool operator !=(XLNumberFormatKey left, XLNumberFormatKey right) => !(left.Equals(right)); + public static bool operator !=(XLNumberFormatKey left, XLNumberFormatKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLNumberFormatValue.cs b/ClosedXML/Excel/Style/XLNumberFormatValue.cs index 360ae8ca3..854718aed 100644 --- a/ClosedXML/Excel/Style/XLNumberFormatValue.cs +++ b/ClosedXML/Excel/Style/XLNumberFormatValue.cs @@ -21,9 +21,9 @@ public static XLNumberFormatValue FromKey(ref XLNumberFormatKey key) public XLNumberFormatKey Key { get; private set; } - public int NumberFormatId { get { return Key.NumberFormatId; } } + public int NumberFormatId => Key.NumberFormatId; - public string Format { get { return Key.Format; } } + public string Format => Key.Format; private XLNumberFormatValue(XLNumberFormatKey key) { @@ -32,8 +32,7 @@ private XLNumberFormatValue(XLNumberFormatKey key) public override bool Equals(object obj) { - var cached = obj as XLNumberFormatValue; - return cached != null && + return obj is XLNumberFormatValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLPredefinedFormat.cs b/ClosedXML/Excel/Style/XLPredefinedFormat.cs index e256a30fb..223b02ed6 100644 --- a/ClosedXML/Excel/Style/XLPredefinedFormat.cs +++ b/ClosedXML/Excel/Style/XLPredefinedFormat.cs @@ -11,7 +11,7 @@ public static class XLPredefinedFormat /// /// General /// - public static int General { get { return 0; } } + public static int General => 0; public enum Number { diff --git a/ClosedXML/Excel/Style/XLProtection.cs b/ClosedXML/Excel/Style/XLProtection.cs index 81045c4c5..4d6cde59e 100644 --- a/ClosedXML/Excel/Style/XLProtection.cs +++ b/ClosedXML/Excel/Style/XLProtection.cs @@ -9,9 +9,14 @@ internal class XLProtection : IXLProtection internal static XLProtectionKey GenerateKey(IXLProtection defaultProtection) { if (defaultProtection == null) + { return XLProtectionValue.Default.Key; + } + if (defaultProtection is XLProtection) + { return (defaultProtection as XLProtection).Key; + } return new XLProtectionKey { @@ -61,7 +66,7 @@ public XLProtection(XLStyle style = null, IXLProtection d = null) : this(style, #region IXLProtection Members - public Boolean Locked + public bool Locked { get { return Key.Locked; } set @@ -70,7 +75,7 @@ public Boolean Locked } } - public Boolean Hidden + public bool Hidden { get { return Key.Hidden; } set @@ -85,7 +90,7 @@ public IXLStyle SetLocked() return _style; } - public IXLStyle SetLocked(Boolean value) + public IXLStyle SetLocked(bool value) { Locked = value; return _style; @@ -97,7 +102,7 @@ public IXLStyle SetHidden() return _style; } - public IXLStyle SetHidden(Boolean value) + public IXLStyle SetHidden(bool value) { Hidden = value; return _style; @@ -126,9 +131,10 @@ public override bool Equals(object obj) public bool Equals(IXLProtection other) { - var otherP = other as XLProtection; - if (otherP == null) + if (!(other is XLProtection otherP)) + { return false; + } return Key == otherP.Key; } @@ -136,7 +142,9 @@ public bool Equals(IXLProtection other) public override string ToString() { if (Locked) + { return Hidden ? "Locked-Hidden" : "Locked"; + } return Hidden ? "Hidden" : "None"; } diff --git a/ClosedXML/Excel/Style/XLProtectionKey.cs b/ClosedXML/Excel/Style/XLProtectionKey.cs index ba4f01320..6cfc39c8a 100644 --- a/ClosedXML/Excel/Style/XLProtectionKey.cs +++ b/ClosedXML/Excel/Style/XLProtectionKey.cs @@ -26,7 +26,10 @@ public bool Equals(XLProtectionKey other) public override bool Equals(object obj) { if (obj is XLProtectionKey) + { return Equals((XLProtectionKey)obj); + } + return base.Equals(obj); } @@ -37,6 +40,6 @@ public override string ToString() public static bool operator ==(XLProtectionKey left, XLProtectionKey right) => left.Equals(right); - public static bool operator !=(XLProtectionKey left, XLProtectionKey right) => !(left.Equals(right)); + public static bool operator !=(XLProtectionKey left, XLProtectionKey right) => !left.Equals(right); } } diff --git a/ClosedXML/Excel/Style/XLProtectionValue.cs b/ClosedXML/Excel/Style/XLProtectionValue.cs index fba99e289..8a6a58f15 100644 --- a/ClosedXML/Excel/Style/XLProtectionValue.cs +++ b/ClosedXML/Excel/Style/XLProtectionValue.cs @@ -21,9 +21,9 @@ public static XLProtectionValue FromKey(ref XLProtectionKey key) public XLProtectionKey Key { get; private set; } - public bool Locked { get { return Key.Locked; } } + public bool Locked => Key.Locked; - public bool Hidden { get { return Key.Hidden; } } + public bool Hidden => Key.Hidden; private XLProtectionValue(XLProtectionKey key) { @@ -32,8 +32,7 @@ private XLProtectionValue(XLProtectionKey key) public override bool Equals(object obj) { - var cached = obj as XLProtectionValue; - return cached != null && + return obj is XLProtectionValue cached && Key.Equals(cached.Key); } diff --git a/ClosedXML/Excel/Style/XLStyle.cs b/ClosedXML/Excel/Style/XLStyle.cs index a09864df3..94ca62230 100644 --- a/ClosedXML/Excel/Style/XLStyle.cs +++ b/ClosedXML/Excel/Style/XLStyle.cs @@ -7,14 +7,19 @@ internal class XLStyle : IXLStyle { #region Static members - public static XLStyle Default { get { return new XLStyle(XLStyleValue.Default); } } + public static XLStyle Default => new XLStyle(XLStyleValue.Default); internal static XLStyleKey GenerateKey(IXLStyle initialStyle) { if (initialStyle == null) + { return Default.Key; + } + if (initialStyle is XLStyle) + { return (initialStyle as XLStyle).Key; + } return new XLStyleKey { @@ -53,7 +58,7 @@ private set #region constructors - public XLStyle(IXLStylized container, IXLStyle initialStyle = null, Boolean useDefaultModify = true) : this(container, GenerateKey(initialStyle)) + public XLStyle(IXLStylized container, IXLStyle initialStyle = null, bool useDefaultModify = true) : this(container, GenerateKey(initialStyle)) { } @@ -63,7 +68,7 @@ public XLStyle(IXLStylized container, XLStyleKey key) : this(container, XLStyleV internal XLStyle(IXLStylized container, XLStyleValue value) { - _container = container ?? new XLStylizedEmpty(XLStyle.Default); + _container = container ?? new XLStylizedEmpty(Default); Value = value; } @@ -126,7 +131,7 @@ public IXLFill Fill } } - public Boolean IncludeQuotePrefix + public bool IncludeQuotePrefix { get { return Value.IncludeQuotePrefix; } set @@ -135,7 +140,7 @@ public Boolean IncludeQuotePrefix } } - public IXLStyle SetIncludeQuotePrefix(Boolean includeQuotePrefix = true) + public IXLStyle SetIncludeQuotePrefix(bool includeQuotePrefix = true) { IncludeQuotePrefix = includeQuotePrefix; return this; @@ -159,10 +164,7 @@ public IXLProtection Protection } } - public IXLNumberFormat DateFormat - { - get { return NumberFormat; } - } + public IXLNumberFormat DateFormat => NumberFormat; #endregion IXLStyle members @@ -188,10 +190,10 @@ public override string ToString() public bool Equals(IXLStyle other) { - var otherS = other as XLStyle; - - if (otherS == null) + if (!(other is XLStyle otherS)) + { return false; + } return Key == otherS.Key && _container == otherS._container; diff --git a/ClosedXML/Excel/Style/XLStyleKey.cs b/ClosedXML/Excel/Style/XLStyleKey.cs index 93fc2b758..a4022dbb8 100644 --- a/ClosedXML/Excel/Style/XLStyleKey.cs +++ b/ClosedXML/Excel/Style/XLStyleKey.cs @@ -12,7 +12,7 @@ internal struct XLStyleKey : IEquatable public XLFontKey Font { get; set; } - public Boolean IncludeQuotePrefix { get; set; } + public bool IncludeQuotePrefix { get; set; } public XLNumberFormatKey NumberFormat { get; set; } @@ -59,20 +59,23 @@ public override string ToString() public override bool Equals(object obj) { if (obj is XLStyleKey) + { return Equals((XLStyleKey)obj); + } + return base.Equals(obj); } public static bool operator ==(XLStyleKey left, XLStyleKey right) => left.Equals(right); - public static bool operator !=(XLStyleKey left, XLStyleKey right) => !(left.Equals(right)); + public static bool operator !=(XLStyleKey left, XLStyleKey right) => !left.Equals(right); public void Deconstruct( out XLAlignmentKey alignment, out XLBorderKey border, out XLFillKey fill, out XLFontKey font, - out Boolean includeQuotePrefix, + out bool includeQuotePrefix, out XLNumberFormatKey numberFormat, out XLProtectionKey protection) { diff --git a/ClosedXML/Excel/Style/XLStyleValue.cs b/ClosedXML/Excel/Style/XLStyleValue.cs index a19651985..d0e4c9ddc 100644 --- a/ClosedXML/Excel/Style/XLStyleValue.cs +++ b/ClosedXML/Excel/Style/XLStyleValue.cs @@ -1,5 +1,4 @@ using ClosedXML.Excel.Caching; -using System; namespace ClosedXML.Excel { @@ -35,7 +34,7 @@ public static XLStyleValue FromKey(ref XLStyleKey key) public XLFontValue Font { get; private set; } - public Boolean IncludeQuotePrefix { get; private set; } + public bool IncludeQuotePrefix { get; private set; } public XLNumberFormatValue NumberFormat { get; private set; } @@ -57,7 +56,9 @@ internal XLStyleValue(XLStyleKey key) public override bool Equals(object obj) { if (ReferenceEquals(this, obj)) + { return true; + } var cached = obj as XLStyleValue; return cached != null && @@ -67,7 +68,9 @@ public override bool Equals(object obj) public override int GetHashCode() { if (_hashCode.HasValue) + { return _hashCode.Value; + } _hashCode = -280332839 + Key.GetHashCode(); return _hashCode.Value; @@ -76,14 +79,26 @@ public override int GetHashCode() public static bool operator ==(XLStyleValue left, XLStyleValue right) { if (ReferenceEquals(left, right)) + { return true; - if (ReferenceEquals(left, null) && ReferenceEquals(right, null)) + } + + if (left is null && right is null) + { return true; - if (ReferenceEquals(left, null) || ReferenceEquals(right, null)) + } + + if (left is null || right is null) + { return false; + } + if (left._hashCode.HasValue && right._hashCode.HasValue && left._hashCode != right._hashCode) + { return false; + } + return left.Key.Equals(right.Key); } diff --git a/ClosedXML/Excel/Style/XLStylizedBase.cs b/ClosedXML/Excel/Style/XLStylizedBase.cs index 325dd5847..37cda85d0 100644 --- a/ClosedXML/Excel/Style/XLStylizedBase.cs +++ b/ClosedXML/Excel/Style/XLStylizedBase.cs @@ -3,7 +3,7 @@ using System.Linq; using System.Runtime.CompilerServices; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.Style { /// /// Base class for any workbook element that has or may have a style. @@ -16,10 +16,8 @@ internal abstract class XLStylizedBase : IXLStylized /// Read-only style property. /// internal XLStyleValue StyleValue { get; private protected set; } - XLStyleValue IXLStylized.StyleValue - { - get { return StyleValue; } - } + + XLStyleValue IXLStylized.StyleValue => StyleValue; /// /// Editable style of the workbook element. Modification of this property DOES affect styles of child objects as well - they will @@ -64,7 +62,9 @@ protected XLStylizedBase(XLStyleValue styleValue = null) private void SetStyle(IXLStyle style, bool propagate = false) { if (style is XLStyle xlStyle) + { SetStyle(xlStyle.Value, propagate); + } else { var styleKey = XLStyle.GenerateKey(style); @@ -86,7 +86,7 @@ private void SetStyle(XLStyleValue value, bool propagate = false) } } - private static ReferenceEqualityComparer _comparer = new ReferenceEqualityComparer(); + private static readonly ReferenceEqualityComparer _comparer = new ReferenceEqualityComparer(); void IXLStylized.ModifyStyle(Func modification) { @@ -123,4 +123,4 @@ public sealed class ReferenceEqualityComparer : IEqualityComparer where T #endregion Nested classes } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Style/XLStylizedEmpty.cs b/ClosedXML/Excel/Style/XLStylizedEmpty.cs index 9f45588ff..cc53ab60c 100644 --- a/ClosedXML/Excel/Style/XLStylizedEmpty.cs +++ b/ClosedXML/Excel/Style/XLStylizedEmpty.cs @@ -1,3 +1,4 @@ +using ClosedXML.Excel.Style; using System.Collections.Generic; namespace ClosedXML.Excel @@ -17,10 +18,7 @@ public override IEnumerable Styles } } - public override IXLRanges RangesUsed - { - get { return new XLRanges(); } - } + public override IXLRanges RangesUsed => new XLRanges(); protected override IEnumerable Children { diff --git a/ClosedXML/Excel/Tables/IXLTable.cs b/ClosedXML/Excel/Tables/IXLTable.cs index e6c291240..7bb285efa 100644 --- a/ClosedXML/Excel/Tables/IXLTable.cs +++ b/ClosedXML/Excel/Tables/IXLTable.cs @@ -1,4 +1,3 @@ -using System; using System.Collections; using System.Collections.Generic; using System.Data; @@ -9,15 +8,15 @@ public interface IXLTable : IXLRange { IXLAutoFilter AutoFilter { get; } IXLTableRange DataRange { get; } - Boolean EmphasizeFirstColumn { get; set; } - Boolean EmphasizeLastColumn { get; set; } + bool EmphasizeFirstColumn { get; set; } + bool EmphasizeLastColumn { get; set; } IEnumerable Fields { get; } string Name { get; set; } - Boolean ShowAutoFilter { get; set; } - Boolean ShowColumnStripes { get; set; } - Boolean ShowHeaderRow { get; set; } - Boolean ShowRowStripes { get; set; } - Boolean ShowTotalsRow { get; set; } + bool ShowAutoFilter { get; set; } + bool ShowColumnStripes { get; set; } + bool ShowHeaderRow { get; set; } + bool ShowRowStripes { get; set; } + bool ShowTotalsRow { get; set; } XLTableTheme Theme { get; set; } /// @@ -40,7 +39,7 @@ public interface IXLTable : IXLRange /// /// The range of the new rows. /// - IXLRange AppendData(IEnumerable data, Boolean propagateExtraColumns = false); + IXLRange AppendData(IEnumerable data, bool propagateExtraColumns = false); /// /// Appends the IEnumerable data elements and returns the range of the new rows. @@ -51,7 +50,7 @@ public interface IXLTable : IXLRange /// /// The range of the new rows. /// - IXLRange AppendData(IEnumerable data, Boolean transpose, Boolean propagateExtraColumns = false); + IXLRange AppendData(IEnumerable data, bool transpose, bool propagateExtraColumns = false); /// /// Appends the data of a data table and returns the range of the new rows. @@ -61,7 +60,7 @@ public interface IXLTable : IXLRange /// /// The range of the new rows. /// - IXLRange AppendData(DataTable dataTable, Boolean propagateExtraColumns = false); + IXLRange AppendData(DataTable dataTable, bool propagateExtraColumns = false); /// /// Appends the IEnumerable data elements and returns the range of the new rows. @@ -72,7 +71,7 @@ public interface IXLTable : IXLRange /// /// The range of the new rows. /// - IXLRange AppendData(IEnumerable data, Boolean propagateExtraColumns = false); + IXLRange AppendData(IEnumerable data, bool propagateExtraColumns = false); /// /// Replaces the IEnumerable data elements and returns the table's data range. @@ -82,7 +81,7 @@ public interface IXLTable : IXLRange /// /// The table's data range. /// - IXLRange ReplaceData(IEnumerable data, Boolean propagateExtraColumns = false); + IXLRange ReplaceData(IEnumerable data, bool propagateExtraColumns = false); /// /// Replaces the IEnumerable data elements and returns the table's data range. @@ -93,7 +92,7 @@ public interface IXLTable : IXLRange /// /// The table's data range. /// - IXLRange ReplaceData(IEnumerable data, Boolean transpose, Boolean propagateExtraColumns = false); + IXLRange ReplaceData(IEnumerable data, bool transpose, bool propagateExtraColumns = false); /// /// Replaces the data from the records of a data table and returns the table's data range. @@ -103,7 +102,7 @@ public interface IXLTable : IXLRange /// /// The table's data range. /// - IXLRange ReplaceData(DataTable dataTable, Boolean propagateExtraColumns = false); + IXLRange ReplaceData(DataTable dataTable, bool propagateExtraColumns = false); /// /// Replaces the IEnumerable data elements as a table and the table's data range. @@ -114,7 +113,7 @@ public interface IXLTable : IXLRange /// /// The table's data range. /// - IXLRange ReplaceData(IEnumerable data, Boolean propagateExtraColumns = false); + IXLRange ReplaceData(IEnumerable data, bool propagateExtraColumns = false); /// /// Resizes the table to the specified range address. @@ -175,31 +174,31 @@ public interface IXLTable : IXLRange IXLTable SetEmphasizeFirstColumn(); - IXLTable SetEmphasizeFirstColumn(Boolean value); + IXLTable SetEmphasizeFirstColumn(bool value); IXLTable SetEmphasizeLastColumn(); - IXLTable SetEmphasizeLastColumn(Boolean value); + IXLTable SetEmphasizeLastColumn(bool value); IXLTable SetShowAutoFilter(); - IXLTable SetShowAutoFilter(Boolean value); + IXLTable SetShowAutoFilter(bool value); IXLTable SetShowColumnStripes(); - IXLTable SetShowColumnStripes(Boolean value); + IXLTable SetShowColumnStripes(bool value); IXLTable SetShowHeaderRow(); - IXLTable SetShowHeaderRow(Boolean value); + IXLTable SetShowHeaderRow(bool value); IXLTable SetShowRowStripes(); - IXLTable SetShowRowStripes(Boolean value); + IXLTable SetShowRowStripes(bool value); IXLTable SetShowTotalsRow(); - IXLTable SetShowTotalsRow(Boolean value); + IXLTable SetShowTotalsRow(bool value); IXLRangeRow TotalsRow(); diff --git a/ClosedXML/Excel/Tables/IXLTableField.cs b/ClosedXML/Excel/Tables/IXLTableField.cs index c1e9107b1..9dad9b13f 100644 --- a/ClosedXML/Excel/Tables/IXLTableField.cs +++ b/ClosedXML/Excel/Tables/IXLTableField.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { public enum XLTotalsRowFunction @@ -58,7 +56,7 @@ public interface IXLTableField /// /// The index. /// - Int32 Index { get; } + int Index { get; } /// /// Gets or sets the name/header of this table field. @@ -67,7 +65,7 @@ public interface IXLTableField /// /// The name. /// - String Name { get; set; } + string Name { get; set; } /// /// Gets the underlying table for this table field. @@ -80,7 +78,7 @@ public interface IXLTableField /// /// The totals row formula a1. /// - String TotalsRowFormulaA1 { get; set; } + string TotalsRowFormulaA1 { get; set; } /// /// Gets or sets the totals row formula in R1C1 format. @@ -88,7 +86,7 @@ public interface IXLTableField /// /// The totals row formula r1 c1. /// - String TotalsRowFormulaR1C1 { get; set; } + string TotalsRowFormulaR1C1 { get; set; } /// /// Gets or sets the totals row function. @@ -104,7 +102,7 @@ public interface IXLTableField /// /// The totals row label. /// - String TotalsRowLabel { get; set; } + string TotalsRowLabel { get; set; } /// /// Deletes this table field from the table. @@ -114,16 +112,16 @@ public interface IXLTableField /// /// Determines whether all cells this table field have a consistent data type. /// - Boolean IsConsistentDataType(); + bool IsConsistentDataType(); /// /// Determines whether all cells this table field have a consistent formula. /// - Boolean IsConsistentFormula(); + bool IsConsistentFormula(); /// /// Determines whether all cells this table field have a consistent style. /// - Boolean IsConsistentStyle(); + bool IsConsistentStyle(); } } diff --git a/ClosedXML/Excel/Tables/IXLTableRange.cs b/ClosedXML/Excel/Tables/IXLTableRange.cs index aeac6b81a..0b11b54cf 100644 --- a/ClosedXML/Excel/Tables/IXLTableRange.cs +++ b/ClosedXML/Excel/Tables/IXLTableRange.cs @@ -7,27 +7,27 @@ public interface IXLTableRange : IXLRange { IXLTable Table { get; } - IXLTableRow FirstRow(Func predicate = null); + IXLTableRow FirstRow(Func predicate = null); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLTableRow FirstRowUsed(Boolean includeFormats, Func predicate = null); + IXLTableRow FirstRowUsed(bool includeFormats, Func predicate = null); - IXLTableRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null); + IXLTableRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null); - IXLTableRow FirstRowUsed(Func predicate = null); + IXLTableRow FirstRowUsed(Func predicate = null); new IXLTableRows InsertRowsAbove(int numberOfRows); new IXLTableRows InsertRowsBelow(int numberOfRows); - IXLTableRow LastRow(Func predicate = null); + IXLTableRow LastRow(Func predicate = null); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLTableRow LastRowUsed(Boolean includeFormats, Func predicate = null); + IXLTableRow LastRowUsed(bool includeFormats, Func predicate = null); - IXLTableRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null); + IXLTableRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null); - IXLTableRow LastRowUsed(Func predicate = null); + IXLTableRow LastRowUsed(Func predicate = null); /// /// Rows the specified row. @@ -36,7 +36,7 @@ public interface IXLTableRange : IXLRange /// new IXLTableRow Row(int row); - IXLTableRows Rows(Func predicate = null); + IXLTableRows Rows(Func predicate = null); /// /// Returns a subset of the rows @@ -49,10 +49,10 @@ public interface IXLTableRange : IXLRange new IXLTableRows Rows(string rows); [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLTableRows RowsUsed(Boolean includeFormats, Func predicate = null); + IXLTableRows RowsUsed(bool includeFormats, Func predicate = null); - IXLTableRows RowsUsed(XLCellsUsedOptions options, Func predicate = null); + IXLTableRows RowsUsed(XLCellsUsedOptions options, Func predicate = null); - IXLTableRows RowsUsed(Func predicate = null); + IXLTableRows RowsUsed(Func predicate = null); } } diff --git a/ClosedXML/Excel/Tables/IXLTableRow.cs b/ClosedXML/Excel/Tables/IXLTableRow.cs index 5722624ad..3e45c8190 100644 --- a/ClosedXML/Excel/Tables/IXLTableRow.cs +++ b/ClosedXML/Excel/Tables/IXLTableRow.cs @@ -1,24 +1,22 @@ -using System; - namespace ClosedXML.Excel { public interface IXLTableRow : IXLRangeRow { - IXLCell Field(Int32 index); + IXLCell Field(int index); - IXLCell Field(String name); + IXLCell Field(string name); new IXLTableRow Sort(); - new IXLTableRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true); + new IXLTableRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true); new IXLTableRow RowAbove(); - new IXLTableRow RowAbove(Int32 step); + new IXLTableRow RowAbove(int step); new IXLTableRow RowBelow(); - new IXLTableRow RowBelow(Int32 step); + new IXLTableRow RowBelow(int step); /// /// Clears the contents of this row. diff --git a/ClosedXML/Excel/Tables/IXLTableRows.cs b/ClosedXML/Excel/Tables/IXLTableRows.cs index 95736844e..bcb641123 100644 --- a/ClosedXML/Excel/Tables/IXLTableRows.cs +++ b/ClosedXML/Excel/Tables/IXLTableRows.cs @@ -29,7 +29,7 @@ public interface IXLTableRows : IEnumerable /// /// if set to true will return all cells with a value or a style different than the default. [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLCells CellsUsed(Boolean includeFormats); + IXLCells CellsUsed(bool includeFormats); IXLCells CellsUsed(XLCellsUsedOptions options); diff --git a/ClosedXML/Excel/Tables/IXLTables.cs b/ClosedXML/Excel/Tables/IXLTables.cs index a9ec66215..fa38beb3c 100644 --- a/ClosedXML/Excel/Tables/IXLTables.cs +++ b/ClosedXML/Excel/Tables/IXLTables.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; using System.Collections.Generic; namespace ClosedXML.Excel @@ -14,16 +13,16 @@ public interface IXLTables : IEnumerable /// Specify what you want to clear. IXLTables Clear(XLClearOptions clearOptions = XLClearOptions.All); - Boolean Contains(String name); + bool Contains(string name); - void Remove(Int32 index); + void Remove(int index); - void Remove(String name); + void Remove(string name); - IXLTable Table(Int32 index); + IXLTable Table(int index); - IXLTable Table(String name); + IXLTable Table(string name); - Boolean TryGetTable(String tableName, out IXLTable table); + bool TryGetTable(string tableName, out IXLTable table); } } diff --git a/ClosedXML/Excel/Tables/XLTable.cs b/ClosedXML/Excel/Tables/XLTable.cs index a6077aba8..918896d2b 100644 --- a/ClosedXML/Excel/Tables/XLTable.cs +++ b/ClosedXML/Excel/Tables/XLTable.cs @@ -1,4 +1,5 @@ -using System; +using ClosedXML.Excel.Ranges; +using System; using System.Collections; using System.Collections.Generic; using System.Data; @@ -7,7 +8,7 @@ using System.Linq; using System.Text; -namespace ClosedXML.Excel +namespace ClosedXML.Excel.Tables { [DebuggerDisplay("{Name}")] internal class XLTable : XLRange, IXLTable @@ -16,7 +17,7 @@ internal class XLTable : XLRange, IXLTable private string _name; internal bool _showTotalsRow; - internal HashSet _uniqueNames; + internal HashSet _uniqueNames; #endregion Private fields @@ -33,25 +34,24 @@ public XLTable(XLRangeParameters xlRangeParameters) #endregion Constructor - public override XLRangeType RangeType - { - get { return XLRangeType.Table; } - } + public override XLRangeType RangeType => XLRangeType.Table; private IXLRangeAddress _lastRangeAddress; - private Dictionary _fieldNames = null; + private Dictionary _fieldNames; - public Dictionary FieldNames + public Dictionary FieldNames { get { if (_fieldNames != null && _lastRangeAddress != null && _lastRangeAddress.Equals(RangeAddress)) + { return _fieldNames; + } _lastRangeAddress = RangeAddress; RescanFieldNames(); - + return _fieldNames; } } @@ -63,11 +63,11 @@ private void RescanFieldNames() var oldFieldNames = _fieldNames ?? new Dictionary(); _fieldNames = new Dictionary(); var headersRow = HeadersRow(false); - Int32 cellPos = 0; + var cellPos = 0; foreach (var cell in headersRow.Cells()) { var name = cell.GetString(); - if (oldFieldNames.TryGetValue(name, out IXLTableField tableField))// && tableField.Column.ColumnNumber() == cell.Address.ColumnNumber) + if (oldFieldNames.TryGetValue(name, out var tableField))// && tableField.Column.ColumnNumber() == cell.Address.ColumnNumber) { (tableField as XLTableField).Index = cellPos; _fieldNames.Add(name, tableField); @@ -76,22 +76,24 @@ private void RescanFieldNames() } // Be careful here. Fields names may actually be whitespace, but not empty - if (String.IsNullOrEmpty(name)) + if (string.IsNullOrEmpty(name)) { name = GetUniqueName("Column", cellPos + 1, true); cell.SetValue(name); cell.DataType = XLDataType.Text; } if (_fieldNames.ContainsKey(name)) + { throw new ArgumentException("The header row contains more than one field name '" + name + "'."); + } _fieldNames.Add(name, new XLTableField(this, name) { Index = cellPos++ }); } } else { - Int32 colCount = ColumnCount(); - for (Int32 i = 1; i <= colCount; i++) + var colCount = ColumnCount(); + for (var i = 1; i <= colCount; i++) { if (_fieldNames.Values.All(f => f.Index != i - 1)) { @@ -103,27 +105,29 @@ private void RescanFieldNames() } } - internal void AddFields(IEnumerable fieldNames) + internal void AddFields(IEnumerable fieldNames) { - _fieldNames = new Dictionary(); + _fieldNames = new Dictionary(); - Int32 cellPos = 0; + var cellPos = 0; foreach (var name in fieldNames) { _fieldNames.Add(name, new XLTableField(this, name) { Index = cellPos++ }); } } - internal void RenameField(String oldName, String newName) + internal void RenameField(string oldName, string newName) { - if (!_fieldNames.TryGetValue(oldName, out IXLTableField field)) - throw new ArgumentException("The field does not exist in this table", "oldName"); + if (!_fieldNames.TryGetValue(oldName, out var field)) + { + throw new ArgumentException("The field does not exist in this table", nameof(oldName)); + } _fieldNames.Remove(oldName); _fieldNames.Add(newName, field); } - internal String RelId { get; set; } + internal string RelId { get; set; } public IXLTableRange DataRange { @@ -135,13 +139,19 @@ public IXLTableRange DataRange var lastDataRowNumber = RowCount(); if (_showHeaderRow) + { firstDataRowNumber++; + } if (_showTotalsRow) + { lastDataRowNumber--; + } if (firstDataRowNumber > lastDataRowNumber) + { return null; + } range = Range(firstDataRowNumber, 1, lastDataRowNumber, ColumnCount()); @@ -156,7 +166,9 @@ public XLAutoFilter AutoFilter get { if (_autoFilter == null) + { _autoFilter = new XLAutoFilter(); + } _autoFilter.Range = ShowTotalsRow ? Range(1, 1, RowCount() - 1, ColumnCount()) : AsRange(); return _autoFilter; @@ -175,14 +187,14 @@ protected override void OnRangeAddressChanged(XLRangeAddress oldAddress, XLRange #region IXLTable Members - public Boolean EmphasizeFirstColumn { get; set; } - public Boolean EmphasizeLastColumn { get; set; } - public Boolean ShowRowStripes { get; set; } - public Boolean ShowColumnStripes { get; set; } + public bool EmphasizeFirstColumn { get; set; } + public bool EmphasizeLastColumn { get; set; } + public bool ShowRowStripes { get; set; } + public bool ShowColumnStripes { get; set; } - private Boolean _showAutoFilter; + private bool _showAutoFilter; - public Boolean ShowAutoFilter + public bool ShowAutoFilter { get { return _showHeaderRow && _showAutoFilter; } set { _showAutoFilter = value; } @@ -190,48 +202,61 @@ public Boolean ShowAutoFilter public XLTableTheme Theme { get; set; } - public String Name + public string Name { get { return _name; } set { - if (_name == value) return; + if (_name == value) + { + return; + } // Validation rules for table names var oldname = _name ?? string.Empty; - if (!XLHelper.ValidateName("table", value, oldname, Worksheet.Tables.Select(t => t.Name), out String message)) + if (!XLHelper.ValidateName("table", value, oldname, Worksheet.Tables.Select(t => t.Name), out var message)) + { throw new ArgumentException(message, nameof(value)); + } _name = value; // Some totals row formula depend on the table name. Update them. if (_fieldNames?.Any() ?? false) - this.Fields.ForEach(f => (f as XLTableField).UpdateTableFieldTotalsRowFormula()); + { + Fields.ForEach(f => (f as XLTableField).UpdateTableFieldTotalsRowFormula()); + } - if (!String.IsNullOrWhiteSpace(oldname) && !String.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) + if (!string.IsNullOrWhiteSpace(oldname) && !string.Equals(oldname, _name, StringComparison.OrdinalIgnoreCase)) { Worksheet.Tables.Add(this); if (Worksheet.Tables.Contains(oldname)) + { Worksheet.Tables.Remove(oldname); + } } } } - public Boolean ShowTotalsRow + public bool ShowTotalsRow { get { return _showTotalsRow; } set { if (value && !_showTotalsRow) + { InsertRowsBelow(1); + } else if (!value && _showTotalsRow) + { TotalsRow().Delete(); + } _showTotalsRow = value; // Invalidate fields' columns - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); if (_showTotalsRow) { @@ -240,7 +265,9 @@ public Boolean ShowTotalsRow RangeAddress.LastAddress.RowNumber - 1, RangeAddress.LastAddress.ColumnNumber); } else + { AutoFilter.Range = Worksheet.Range(RangeAddress); + } } } @@ -249,13 +276,16 @@ public IXLRangeRow HeadersRow() return HeadersRow(true); } - internal IXLRangeRow HeadersRow(Boolean scanForNewFieldsNames) + internal IXLRangeRow HeadersRow(bool scanForNewFieldsNames) { - if (!ShowHeaderRow) return null; + if (!ShowHeaderRow) + { + return null; + } if (scanForNewFieldsNames) { - var tempResult = FieldNames; + _ = FieldNames; } return FirstRow(); @@ -266,12 +296,12 @@ public IXLRangeRow TotalsRow() return ShowTotalsRow ? LastRow() : null; } - public IXLTableField Field(String fieldName) + public IXLTableField Field(string fieldName) { return Field(GetFieldIndex(fieldName)); } - public IXLTableField Field(Int32 fieldIndex) + public IXLTableField Field(int fieldIndex) { return FieldNames.Values.First(f => f.Index == fieldIndex); } @@ -280,9 +310,11 @@ public IEnumerable Fields { get { - Int32 columnCount = ColumnCount(); - for (int co = 0; co < columnCount; co++) + var columnCount = ColumnCount(); + for (var co = 0; co < columnCount; co++) + { yield return Field(co); + } } } @@ -318,37 +350,45 @@ public IXLTable Resize(int firstCellRow, int firstCellColumn, int lastCellRow, i public IXLTable Resize(IXLRange range) { - if (!this.ShowHeaderRow) + if (!ShowHeaderRow) + { throw new NotImplementedException("Resizing of tables with no headers not supported yet."); + } - if (this.Worksheet != range.Worksheet) + if (Worksheet != range.Worksheet) + { throw new InvalidOperationException("You cannot resize a table to a range on a different sheet."); + } - var totalsRowChanged = this.ShowTotalsRow ? range.LastRow().RowNumber() - this.TotalsRow().RowNumber() : 0; - var oldTotalsRowNumber = this.ShowTotalsRow ? this.TotalsRow().RowNumber() : -1; + var totalsRowChanged = ShowTotalsRow ? range.LastRow().RowNumber() - TotalsRow().RowNumber() : 0; + var oldTotalsRowNumber = ShowTotalsRow ? TotalsRow().RowNumber() : -1; - var existingHeaders = this.FieldNames.Keys; + var existingHeaders = FieldNames.Keys; var newHeaders = new HashSet(); // Force evaluation of f.Column field - var tempArray = this.Fields.Select(f => f.Column).ToArray(); + _ = Fields.Select(f => f.Column).ToArray(); var firstRow = range.Row(1); - if (!firstRow.FirstCell().Address.Equals(this.HeadersRow().FirstCell().Address) - || !firstRow.LastCell().Address.Equals(this.HeadersRow().LastCell().Address)) + if (!firstRow.FirstCell().Address.Equals(HeadersRow().FirstCell().Address) + || !firstRow.LastCell().Address.Equals(HeadersRow().LastCell().Address)) { _uniqueNames.Clear(); var co = 1; foreach (var c in firstRow.Cells()) { - if (String.IsNullOrWhiteSpace(((XLCell)c).InnerText)) + if (string.IsNullOrWhiteSpace(((XLCell)c).InnerText)) + { c.Value = GetUniqueName("Column", co, true); + } var header = c.GetString(); _uniqueNames.Add(header); if (!existingHeaders.Contains(header)) + { newHeaders.Add(header); + } co++; } @@ -356,24 +396,24 @@ public IXLTable Resize(IXLRange range) if (totalsRowChanged < 0) { - range.Rows(r => r.RowNumber().Equals(this.TotalsRow().RowNumber() + totalsRowChanged)).Single().InsertRowsAbove(1); + range.Rows(r => r.RowNumber().Equals(TotalsRow().RowNumber() + totalsRowChanged)).Single().InsertRowsAbove(1); range = Worksheet.Range(range.FirstCell(), range.LastCell().CellAbove()); oldTotalsRowNumber++; } else if (totalsRowChanged > 0) { - this.TotalsRow().RowBelow(totalsRowChanged + 1).InsertRowsAbove(1); - this.TotalsRow().AsRange().Delete(XLShiftDeletedCells.ShiftCellsUp); + TotalsRow().RowBelow(totalsRowChanged + 1).InsertRowsAbove(1); + TotalsRow().AsRange().Delete(XLShiftDeletedCells.ShiftCellsUp); } - this.RangeAddress = (XLRangeAddress)range.RangeAddress; + RangeAddress = (XLRangeAddress)range.RangeAddress; RescanFieldNames(); - if (this.ShowTotalsRow) + if (ShowTotalsRow) { - foreach (var f in this._fieldNames.Values) + foreach (var f in _fieldNames.Values) { - var c = this.TotalsRow().Cell(f.Index + 1); + var c = TotalsRow().Cell(f.Index + 1); if (!c.IsEmpty() && newHeaders.Contains(f.Name)) { f.TotalsRowLabel = c.GetFormattedString(); @@ -383,25 +423,31 @@ public IXLTable Resize(IXLRange range) if (totalsRowChanged != 0) { - foreach (var f in this._fieldNames.Values.Cast()) + foreach (var f in _fieldNames.Values.Cast()) { f.UpdateTableFieldTotalsRowFormula(); - var c = this.TotalsRow().Cell(f.Index + 1); - if (!String.IsNullOrWhiteSpace(f.TotalsRowLabel)) + var c = TotalsRow().Cell(f.Index + 1); + if (!string.IsNullOrWhiteSpace(f.TotalsRowLabel)) { c.DataType = XLDataType.Text; //Remove previous row's label - var oldTotalsCell = this.Worksheet.Cell(oldTotalsRowNumber, f.Column.ColumnNumber()); + var oldTotalsCell = Worksheet.Cell(oldTotalsRowNumber, f.Column.ColumnNumber()); if (oldTotalsCell.Value.ToString() == f.TotalsRowLabel) + { oldTotalsCell.Value = null; + } } if (f.TotalsRowFunction != XLTotalsRowFunction.None) + { c.DataType = XLDataType.Number; + } if (!string.IsNullOrEmpty(f.TotalsRowLabel)) + { c.SetValue(f.TotalsRowLabel); + } } } } @@ -415,7 +461,7 @@ public IXLTable SetEmphasizeFirstColumn() return this; } - public IXLTable SetEmphasizeFirstColumn(Boolean value) + public IXLTable SetEmphasizeFirstColumn(bool value) { EmphasizeFirstColumn = value; return this; @@ -427,7 +473,7 @@ public IXLTable SetEmphasizeLastColumn() return this; } - public IXLTable SetEmphasizeLastColumn(Boolean value) + public IXLTable SetEmphasizeLastColumn(bool value) { EmphasizeLastColumn = value; return this; @@ -439,7 +485,7 @@ public IXLTable SetShowRowStripes() return this; } - public IXLTable SetShowRowStripes(Boolean value) + public IXLTable SetShowRowStripes(bool value) { ShowRowStripes = value; return this; @@ -451,7 +497,7 @@ public IXLTable SetShowColumnStripes() return this; } - public IXLTable SetShowColumnStripes(Boolean value) + public IXLTable SetShowColumnStripes(bool value) { ShowColumnStripes = value; return this; @@ -463,7 +509,7 @@ public IXLTable SetShowTotalsRow() return this; } - public IXLTable SetShowTotalsRow(Boolean value) + public IXLTable SetShowTotalsRow(bool value) { ShowTotalsRow = value; return this; @@ -475,20 +521,20 @@ public IXLTable SetShowAutoFilter() return this; } - public IXLTable SetShowAutoFilter(Boolean value) + public IXLTable SetShowAutoFilter(bool value) { ShowAutoFilter = value; return this; } - public new IXLRange Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, - Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange Sort(string columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, + bool matchCase = false, bool ignoreBlanks = true) { var toSortBy = new StringBuilder(); - foreach (string coPairTrimmed in columnsToSortBy.Split(',').Select(coPair => coPair.Trim())) + foreach (var coPairTrimmed in columnsToSortBy.Split(',').Select(coPair => coPair.Trim())) { - String coString; - String order; + string coString; + string order; if (coPairTrimmed.Contains(' ')) { var pair = coPairTrimmed.Split(' '); @@ -501,11 +547,15 @@ public IXLTable SetShowAutoFilter(Boolean value) order = sortOrder == XLSortOrder.Ascending ? "ASC" : "DESC"; } - if (!Int32.TryParse(coString, out Int32 co)) + if (!int.TryParse(coString, out var co)) + { co = Field(coString).Index + 1; + } if (toSortBy.Length > 0) + { toSortBy.Append(','); + } toSortBy.Append(co); toSortBy.Append(' '); @@ -520,25 +570,26 @@ public IXLTable SetShowAutoFilter(Boolean value) return this; } - IXLAutoFilter IXLTable.AutoFilter - { - get { return AutoFilter; } - } + IXLAutoFilter IXLTable.AutoFilter => AutoFilter; #endregion IXLTable Members - private void InitializeValues(Boolean setAutofilter) + private void InitializeValues(bool setAutofilter) { ShowRowStripes = true; _showHeaderRow = true; Theme = XLTableTheme.TableStyleMedium2; if (setAutofilter) + { InitializeAutoFilter(); + } AsRange().Row(1).DataType = XLDataType.Text; if (RowCount() == 1) + { InsertRowsBelow(1); + } } public void InitializeAutoFilter() @@ -549,23 +600,26 @@ public void InitializeAutoFilter() internal void OnAddedToTables() { _uniqueNames = new HashSet(); - Int32 co = 1; - foreach (IXLCell c in Row(1).Cells()) + var co = 1; + foreach (var c in Row(1).Cells()) { // Be careful here. Fields names may actually be whitespace, but not empty - if (String.IsNullOrEmpty(((XLCell)c).InnerText)) + if (string.IsNullOrEmpty(((XLCell)c).InnerText)) + { c.Value = GetUniqueName("Column", co, true); + } + _uniqueNames.Add(c.GetString()); co++; } } - private String GetUniqueName(String originalName, Int32 initialOffset, Boolean enforceOffset) + private string GetUniqueName(string originalName, int initialOffset, bool enforceOffset) { - String name = String.Concat(originalName, enforceOffset ? initialOffset.ToInvariantString() : string.Empty); + var name = string.Concat(originalName, enforceOffset ? initialOffset.ToInvariantString() : string.Empty); if (_uniqueNames?.Contains(name) ?? false) { - Int32 i = initialOffset; + var i = initialOffset; name = originalName + i.ToInvariantString(); while (_uniqueNames.Contains(name)) { @@ -577,36 +631,44 @@ private String GetUniqueName(String originalName, Int32 initialOffset, Boolean e return name; } - public Int32 GetFieldIndex(String name) + public int GetFieldIndex(string name) { // There is a discrepancy in the way headers with line breaks are stored. // The entry in the table definition will contain \r\n // but the shared string value of the actual cell will contain only \n name = name.Replace("\r\n", "\n"); - if (FieldNames.TryGetValue(name, out IXLTableField tableField)) + if (FieldNames.TryGetValue(name, out var tableField)) + { return tableField.Index; + } throw new ArgumentOutOfRangeException("The header row doesn't contain field name '" + name + "'."); } - internal Boolean _showHeaderRow; + internal bool _showHeaderRow; - public Boolean ShowHeaderRow + public bool ShowHeaderRow { get { return _showHeaderRow; } set { - if (_showHeaderRow == value) return; + if (_showHeaderRow == value) + { + return; + } if (_showHeaderRow) { var headersRow = HeadersRow(); _uniqueNames = new HashSet(); - Int32 co = 1; - foreach (IXLCell c in headersRow.Cells()) + var co = 1; + foreach (var c in headersRow.Cells()) { - if (String.IsNullOrWhiteSpace(((XLCell)c).InnerText)) + if (string.IsNullOrWhiteSpace(((XLCell)c).InnerText)) + { c.Value = GetUniqueName("Column", co, true); + } + _uniqueNames.Add(c.GetString()); co++; } @@ -651,7 +713,7 @@ public Boolean ShowHeaderRow RangeAddress.LastAddress); } - Int32 co = 1; + var co = 1; foreach (var name in FieldNames.Values.Select(f => f.Name)) { rangeRow.Cell(co).SetValue(name); @@ -662,10 +724,12 @@ public Boolean ShowHeaderRow _showHeaderRow = value; // Invalidate fields' columns - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); if (_showHeaderRow) + { HeadersRow().DataType = XLDataType.Text; + } } } @@ -674,13 +738,13 @@ public IXLTable SetShowHeaderRow() return SetShowHeaderRow(true); } - public IXLTable SetShowHeaderRow(Boolean value) + public IXLTable SetShowHeaderRow(bool value) { ShowHeaderRow = value; return this; } - public void ExpandTableRows(Int32 rows) + public void ExpandTableRows(int rows) { RangeAddress = new XLRangeAddress( RangeAddress.FirstAddress, @@ -746,22 +810,22 @@ internal override XLRangeColumns ColumnsUsed(Func predicat return columns; } - IXLPivotTable IXLRangeBase.CreatePivotTable(IXLCell targetCell, String name) + IXLPivotTable IXLRangeBase.CreatePivotTable(IXLCell targetCell, string name) { return CreatePivotTable(targetCell, name); } - internal new XLPivotTable CreatePivotTable(IXLCell targetCell, String name) + internal new XLPivotTable CreatePivotTable(IXLCell targetCell, string name) { return (XLPivotTable)targetCell.Worksheet.PivotTables.Add(name, targetCell, this); } public IEnumerable AsDynamicEnumerable() { - foreach (var row in this.DataRange.Rows()) + foreach (var row in DataRange.Rows()) { dynamic expando = new ExpandoObject(); - foreach (var f in this.Fields) + foreach (var f in Fields) { var value = row.Cell(f.Index + 1).Value; // ExpandoObject supports IDictionary so we can extend it like this @@ -775,22 +839,22 @@ public IEnumerable AsDynamicEnumerable() public DataTable AsNativeDataTable() { - var table = new DataTable(this.Name); + var table = new DataTable(Name); foreach (var f in Fields.Cast()) { - Type type = typeof(object); + var type = typeof(object); if (f.IsConsistentDataType()) { - var c = f.Column.Cells().Skip(this.ShowHeaderRow ? 1 : 0).First(); + var c = f.Column.Cells().Skip(ShowHeaderRow ? 1 : 0).First(); switch (c.DataType) { case XLDataType.Text: - type = typeof(String); + type = typeof(string); break; case XLDataType.Boolean: - type = typeof(Boolean); + type = typeof(bool); break; case XLDataType.DateTime: @@ -802,7 +866,7 @@ public DataTable AsNativeDataTable() break; case XLDataType.Number: - type = typeof(Double); + type = typeof(double); break; } } @@ -810,11 +874,11 @@ public DataTable AsNativeDataTable() table.Columns.Add(f.Name, type); } - foreach (var row in this.DataRange.Rows()) + foreach (var row in DataRange.Rows()) { var dr = table.NewRow(); - foreach (var f in this.Fields) + foreach (var f in Fields) { dr[f.Name] = row.Cell(f.Index + 1).Value; } @@ -833,15 +897,21 @@ public IXLTable CopyTo(IXLWorksheet targetSheet) internal IXLTable CopyTo(XLWorksheet targetSheet, bool copyData = true) { if (targetSheet == Worksheet) + { throw new InvalidOperationException("Cannot copy table to the worksheet it already belongs to."); + } var targetRange = targetSheet.Range(RangeAddress.WithoutWorksheet()); if (copyData) + { RangeUsed().CopyTo(targetRange); + } else + { HeadersRow().CopyTo(targetRange.FirstRow()); + } - String tableName = Name; + var tableName = Name; var newTable = (XLTable)targetSheet.Table(targetRange, tableName, true); newTable.RelId = null; @@ -853,8 +923,8 @@ internal IXLTable CopyTo(XLWorksheet targetSheet, bool copyData = true) newTable.Theme = Theme; newTable._showTotalsRow = ShowTotalsRow; - Int32 fieldCount = ColumnCount(); - for (Int32 f = 0; f < fieldCount; f++) + var fieldCount = ColumnCount(); + for (var f = 0; f < fieldCount; f++) { var tableField = newTable.Field(f) as XLTableField; var tField = Field(f) as XLTableField; @@ -868,22 +938,24 @@ internal IXLTable CopyTo(XLWorksheet targetSheet, bool copyData = true) #region Append and replace data - public IXLRange AppendData(IEnumerable data, Boolean propagateExtraColumns = false) + public IXLRange AppendData(IEnumerable data, bool propagateExtraColumns = false) { return AppendData(data, transpose: false, propagateExtraColumns: propagateExtraColumns); } - public IXLRange AppendData(IEnumerable data, bool transpose, Boolean propagateExtraColumns = false) + public IXLRange AppendData(IEnumerable data, bool transpose, bool propagateExtraColumns = false) { var castedData = data?.Cast(); - if (!(castedData?.Any() ?? false) || data is String) + if (!(castedData?.Any() ?? false) || data is string) + { return null; + } var numberOfNewRows = castedData.Count(); - var lastRowOfOldRange = this.DataRange.LastRow(); + var lastRowOfOldRange = DataRange.LastRow(); lastRowOfOldRange.InsertRowsBelow(numberOfNewRows); - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); var insertedRange = lastRowOfOldRange.RowBelow().FirstCell().InsertData(castedData, transpose); @@ -892,24 +964,28 @@ public IXLRange AppendData(IEnumerable data, bool transpose, Boolean propagateEx return insertedRange; } - public IXLRange AppendData(DataTable dataTable, Boolean propagateExtraColumns = false) + public IXLRange AppendData(DataTable dataTable, bool propagateExtraColumns = false) { return AppendData(dataTable.Rows.Cast(), propagateExtraColumns: propagateExtraColumns); } - public IXLRange AppendData(IEnumerable data, Boolean propagateExtraColumns = false) + public IXLRange AppendData(IEnumerable data, bool propagateExtraColumns = false) { - if (!(data?.Any() ?? false) || data is String) + if (!(data?.Any() ?? false) || data is string) + { return null; + } var numberOfNewRows = data.Count(); if (numberOfNewRows == 0) + { return null; + } - var lastRowOfOldRange = this.DataRange.LastRow(); + var lastRowOfOldRange = DataRange.LastRow(); lastRowOfOldRange.InsertRowsBelow(numberOfNewRows); - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); var insertedRange = lastRowOfOldRange.RowBelow().FirstCell().InsertData(data); @@ -918,27 +994,31 @@ public IXLRange AppendData(IEnumerable data, Boolean propagateExtraColumns return insertedRange; } - public IXLRange ReplaceData(IEnumerable data, Boolean propagateExtraColumns = false) + public IXLRange ReplaceData(IEnumerable data, bool propagateExtraColumns = false) { return ReplaceData(data, transpose: false, propagateExtraColumns: propagateExtraColumns); } - public IXLRange ReplaceData(IEnumerable data, bool transpose, Boolean propagateExtraColumns = false) + public IXLRange ReplaceData(IEnumerable data, bool transpose, bool propagateExtraColumns = false) { var castedData = data?.Cast(); - if (!(castedData?.Any() ?? false) || data is String) + if (!(castedData?.Any() ?? false) || data is string) + { throw new InvalidOperationException("Cannot replace table data with empty enumerable."); + } - var firstDataRowNumber = this.DataRange.FirstRow().RowNumber(); - var lastDataRowNumber = this.DataRange.LastRow().RowNumber(); + var firstDataRowNumber = DataRange.FirstRow().RowNumber(); + var lastDataRowNumber = DataRange.LastRow().RowNumber(); // Resize table - var sizeDifference = castedData.Count() - this.DataRange.RowCount(); + var sizeDifference = castedData.Count() - DataRange.RowCount(); if (sizeDifference > 0) - this.DataRange.LastRow().InsertRowsBelow(sizeDifference); + { + DataRange.LastRow().InsertRowsBelow(sizeDifference); + } else if (sizeDifference < 0) { - this.DataRange.Rows + DataRange.Rows ( lastDataRowNumber + sizeDifference + 1 - firstDataRowNumber + 1, lastDataRowNumber - firstDataRowNumber + 1 @@ -950,37 +1030,45 @@ public IXLRange ReplaceData(IEnumerable data, bool transpose, Boolean propagateE } if (sizeDifference != 0) + { // Invalidate table fields' columns - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); + } - var replacedRange = this.DataRange.FirstCell().InsertData(castedData, transpose); + var replacedRange = DataRange.FirstCell().InsertData(castedData, transpose); if (propagateExtraColumns) + { PropagateExtraColumns(replacedRange.ColumnCount(), lastDataRowNumber); + } return replacedRange; } - public IXLRange ReplaceData(DataTable dataTable, Boolean propagateExtraColumns = false) + public IXLRange ReplaceData(DataTable dataTable, bool propagateExtraColumns = false) { return ReplaceData(dataTable.Rows.Cast(), propagateExtraColumns: propagateExtraColumns); } - public IXLRange ReplaceData(IEnumerable data, Boolean propagateExtraColumns = false) + public IXLRange ReplaceData(IEnumerable data, bool propagateExtraColumns = false) { - if (!(data?.Any() ?? false) || data is String) + if (!(data?.Any() ?? false) || data is string) + { throw new InvalidOperationException("Cannot replace table data with empty enumerable."); + } - var firstDataRowNumber = this.DataRange.FirstRow().RowNumber(); - var lastDataRowNumber = this.DataRange.LastRow().RowNumber(); + var firstDataRowNumber = DataRange.FirstRow().RowNumber(); + var lastDataRowNumber = DataRange.LastRow().RowNumber(); // Resize table - var sizeDifference = data.Count() - this.DataRange.RowCount(); + var sizeDifference = data.Count() - DataRange.RowCount(); if (sizeDifference > 0) - this.DataRange.LastRow().InsertRowsBelow(sizeDifference); + { + DataRange.LastRow().InsertRowsBelow(sizeDifference); + } else if (sizeDifference < 0) { - this.DataRange.Rows + DataRange.Rows ( lastDataRowNumber + sizeDifference + 1 - firstDataRowNumber + 1, lastDataRowNumber - firstDataRowNumber + 1 @@ -992,35 +1080,43 @@ public IXLRange ReplaceData(IEnumerable data, Boolean propagateExtraColumn } if (sizeDifference != 0) + { // Invalidate table fields' columns - this.Fields.Cast().ForEach(f => f.Column = null); + Fields.Cast().ForEach(f => f.Column = null); + } - var replacedRange = this.DataRange.FirstCell().InsertData(data); + var replacedRange = DataRange.FirstCell().InsertData(data); if (propagateExtraColumns) + { PropagateExtraColumns(replacedRange.ColumnCount(), lastDataRowNumber); + } return replacedRange; } private void PropagateExtraColumns(int numberOfNonExtraColumns, int previousLastDataRow) { - for (var i = numberOfNonExtraColumns; i < this.Fields.Count(); i++) + for (var i = numberOfNonExtraColumns; i < Fields.Count(); i++) { - var field = this.Field(i); + var field = Field(i); - var cell = this.Worksheet.Cell(previousLastDataRow, field.Column.ColumnNumber()); + var cell = Worksheet.Cell(previousLastDataRow, field.Column.ColumnNumber()); field.Column.Cells(c => c.Address.RowNumber > previousLastDataRow) .ForEach(c => { if (cell.HasFormula) + { c.FormulaR1C1 = cell.FormulaR1C1; + } else + { c.Value = cell.Value; + } }); } } #endregion Append and replace data } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/Tables/XLTableField.cs b/ClosedXML/Excel/Tables/XLTableField.cs index 6d3f88ccc..947fd8dd7 100644 --- a/ClosedXML/Excel/Tables/XLTableField.cs +++ b/ClosedXML/Excel/Tables/XLTableField.cs @@ -1,4 +1,4 @@ -using System; +using ClosedXML.Excel.Tables; using System.Collections.Generic; using System.Diagnostics; using System.Linq; @@ -9,14 +9,14 @@ namespace ClosedXML.Excel internal class XLTableField : IXLTableField { internal XLTotalsRowFunction totalsRowFunction; - internal String totalsRowLabel; + internal string totalsRowLabel; private readonly XLTable table; private IXLRangeColumn _column; - private Int32 index; - private String name; + private int index; + private string name; - public XLTableField(XLTable table, String name) + public XLTableField(XLTable table, string name) { this.table = table; this.name = name; @@ -28,7 +28,7 @@ public IXLRangeColumn Column { if (_column == null) { - _column = table.AsRange().Column(this.Index + 1); + _column = table.AsRange().Column(Index + 1); } return _column; } @@ -38,44 +38,50 @@ internal set } } - public IXLCells DataCells - { - get - { - return Column.Cells(c => - { - if (table.ShowHeaderRow && c == HeaderCell) - return false; - if (table.ShowTotalsRow && c == TotalsCell) - return false; - return true; - }); - } - } + public IXLCells DataCells => Column.Cells(c => + { + if (table.ShowHeaderRow && c == HeaderCell) + { + return false; + } + + if (table.ShowTotalsRow && c == TotalsCell) + { + return false; + } + + return true; + }); public IXLCell HeaderCell { get { if (!table.ShowHeaderRow) + { return null; + } return Column.FirstCell(); } } - public Int32 Index + public int Index { get { return index; } internal set { - if (index == value) return; + if (index == value) + { + return; + } + index = value; _column = null; } } - public String Name + public string Name { get { @@ -83,30 +89,37 @@ public String Name } set { - if (name == value) return; + if (name == value) + { + return; + } if (table.ShowHeaderRow) + { (table.HeadersRow(false).Cell(Index + 1) as XLCell).SetValue(value, setTableHeader: false, checkMergedRanges: true); + } table.RenameField(name, value); name = value; } } - public IXLTable Table { get { return table; } } + public IXLTable Table => table; public IXLCell TotalsCell { get { if (!table.ShowTotalsRow) + { return null; + } return Column.LastCell(); } } - public String TotalsRowFormulaA1 + public string TotalsRowFormulaA1 { get { return table.TotalsRow().Cell(Index + 1).FormulaA1; } set @@ -116,7 +129,7 @@ public String TotalsRowFormulaA1 } } - public String TotalsRowFormulaR1C1 + public string TotalsRowFormulaR1C1 { get { return table.TotalsRow().Cell(Index + 1).FormulaR1C1; } set @@ -136,7 +149,7 @@ public XLTotalsRowFunction TotalsRowFunction } } - public String TotalsRowLabel + public string TotalsRowLabel { get { return totalsRowLabel; } set @@ -152,28 +165,30 @@ public void Delete() Delete(true); } - internal void Delete(Boolean deleteUnderlyingRangeColumn) + internal void Delete(bool deleteUnderlyingRangeColumn) { var fields = table.Fields.Cast().ToArray(); if (deleteUnderlyingRangeColumn) { - table.AsRange().ColumnQuick(this.Index + 1).Delete(); + table.AsRange().ColumnQuick(Index + 1).Delete(); } - fields.Where(f => f.Index > this.Index).ForEach(f => f.Index--); - table.FieldNames.Remove(this.Name); + fields.Where(f => f.Index > Index).ForEach(f => f.Index--); + table.FieldNames.Remove(Name); } public bool IsConsistentDataType() { - var dataTypes = this.Column + var dataTypes = Column .Cells() - .Skip(this.table.ShowHeaderRow ? 1 : 0) + .Skip(table.ShowHeaderRow ? 1 : 0) .Select(c => c.DataType); - if (this.table.ShowTotalsRow) + if (table.ShowTotalsRow) + { dataTypes = dataTypes.Take(dataTypes.Count() - 1); + } var distinctDataTypes = dataTypes .GroupBy(dt => dt) @@ -182,15 +197,17 @@ public bool IsConsistentDataType() return distinctDataTypes.Count() == 1; } - public Boolean IsConsistentFormula() + public bool IsConsistentFormula() { - var formulas = this.Column + var formulas = Column .Cells() - .Skip(this.table.ShowHeaderRow ? 1 : 0) + .Skip(table.ShowHeaderRow ? 1 : 0) .Select(c => c.FormulaR1C1); - if (this.table.ShowTotalsRow) + if (table.ShowTotalsRow) + { formulas = formulas.Take(formulas.Count() - 1); + } var distinctFormulas = formulas .GroupBy(f => f) @@ -201,14 +218,16 @@ public Boolean IsConsistentFormula() public bool IsConsistentStyle() { - var styles = this.Column + var styles = Column .Cells() - .Skip(this.table.ShowHeaderRow ? 1 : 0) + .Skip(table.ShowHeaderRow ? 1 : 0) .OfType() .Select(c => c.StyleValue); - if (this.table.ShowTotalsRow) + if (table.ShowTotalsRow) + { styles = styles.Take(styles.Count() - 1); + } var distinctStyles = styles .Distinct(); @@ -216,14 +235,14 @@ public bool IsConsistentStyle() return distinctStyles.Count() == 1; } - private static IEnumerable QuotedTableFieldCharacters = new[] { "'", "#" }; + private static readonly IEnumerable QuotedTableFieldCharacters = new[] { "'", "#" }; internal void UpdateTableFieldTotalsRowFormula() { if (TotalsRowFunction != XLTotalsRowFunction.None && TotalsRowFunction != XLTotalsRowFunction.Custom) { var cell = table.TotalsRow().Cell(Index + 1); - var formulaCode = String.Empty; + var formulaCode = string.Empty; switch (TotalsRowFunction) { case XLTotalsRowFunction.Sum: formulaCode = "109"; break; diff --git a/ClosedXML/Excel/Tables/XLTableRange.cs b/ClosedXML/Excel/Tables/XLTableRange.cs index 717f1491e..b4cfab618 100644 --- a/ClosedXML/Excel/Tables/XLTableRange.cs +++ b/ClosedXML/Excel/Tables/XLTableRange.cs @@ -1,9 +1,10 @@ +using ClosedXML.Excel.Ranges; +using ClosedXML.Excel.Tables; using System; +using System.Linq; namespace ClosedXML.Excel { - using System.Linq; - internal class XLTableRange : XLRange, IXLTableRange { private readonly XLTable _table; @@ -15,37 +16,42 @@ public XLTableRange(XLRange range, XLTable table) _range = range; } - IXLTableRow IXLTableRange.FirstRow(Func predicate) + IXLTableRow IXLTableRange.FirstRow(Func predicate) { return FirstRow(predicate); } - public XLTableRow FirstRow(Func predicate = null) + public XLTableRow FirstRow(Func predicate = null) { if (predicate == null) - return new XLTableRow(this, (_range.FirstRow())); + { + return new XLTableRow(this, _range.FirstRow()); + } - Int32 rowCount = _range.RowCount(); + var rowCount = _range.RowCount(); - for (Int32 ro = 1; ro <= rowCount; ro++) + for (var ro = 1; ro <= rowCount; ro++) { - var row = new XLTableRow(this, (_range.Row(ro))); - if (predicate(row)) return row; + var row = new XLTableRow(this, _range.Row(ro)); + if (predicate(row)) + { + return row; + } } return null; } - IXLTableRow IXLTableRange.FirstRowUsed(Func predicate) + IXLTableRow IXLTableRange.FirstRowUsed(Func predicate) { return FirstRowUsed(XLCellsUsedOptions.AllContents, predicate); } - public XLTableRow FirstRowUsed(Func predicate = null) + public XLTableRow FirstRowUsed(Func predicate = null) { return FirstRowUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLTableRow IXLTableRange.FirstRowUsed(Boolean includeFormats, Func predicate) + IXLTableRow IXLTableRange.FirstRowUsed(bool includeFormats, Func predicate) { return FirstRowUsed(includeFormats ? XLCellsUsedOptions.All @@ -53,60 +59,69 @@ IXLTableRow IXLTableRange.FirstRowUsed(Boolean includeFormats, Func predicate) + IXLTableRow IXLTableRange.FirstRowUsed(XLCellsUsedOptions options, Func predicate) { return FirstRowUsed(options, predicate); } - internal XLTableRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLTableRow FirstRowUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) - return new XLTableRow(this, (_range.FirstRowUsed(options))); + { + return new XLTableRow(this, _range.FirstRowUsed(options)); + } - Int32 rowCount = _range.RowCount(); + var rowCount = _range.RowCount(); - for (Int32 ro = 1; ro <= rowCount; ro++) + for (var ro = 1; ro <= rowCount; ro++) { - var row = new XLTableRow(this, (_range.Row(ro))); + var row = new XLTableRow(this, _range.Row(ro)); if (!row.IsEmpty(options) && predicate(row)) + { return row; + } } return null; } - IXLTableRow IXLTableRange.LastRow(Func predicate) + IXLTableRow IXLTableRange.LastRow(Func predicate) { return LastRow(predicate); } - public XLTableRow LastRow(Func predicate = null) + public XLTableRow LastRow(Func predicate = null) { if (predicate == null) - return new XLTableRow(this, (_range.LastRow())); + { + return new XLTableRow(this, _range.LastRow()); + } - Int32 rowCount = _range.RowCount(); + var rowCount = _range.RowCount(); - for (Int32 ro = rowCount; ro >= 1; ro--) + for (var ro = rowCount; ro >= 1; ro--) { - var row = new XLTableRow(this, (_range.Row(ro))); - if (predicate(row)) return row; + var row = new XLTableRow(this, _range.Row(ro)); + if (predicate(row)) + { + return row; + } } return null; } - IXLTableRow IXLTableRange.LastRowUsed(Func predicate) + IXLTableRow IXLTableRange.LastRowUsed(Func predicate) { return LastRowUsed(XLCellsUsedOptions.AllContents, predicate); } - public XLTableRow LastRowUsed(Func predicate = null) + public XLTableRow LastRowUsed(Func predicate = null) { return LastRowUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLTableRow IXLTableRange.LastRowUsed(Boolean includeFormats, Func predicate) + IXLTableRow IXLTableRange.LastRowUsed(bool includeFormats, Func predicate) { return LastRowUsed(includeFormats ? XLCellsUsedOptions.All @@ -114,25 +129,29 @@ IXLTableRow IXLTableRange.LastRowUsed(Boolean includeFormats, Func predicate) + IXLTableRow IXLTableRange.LastRowUsed(XLCellsUsedOptions options, Func predicate) { return LastRowUsed(options, predicate); } - internal XLTableRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLTableRow LastRowUsed(XLCellsUsedOptions options, Func predicate = null) { if (predicate == null) - return new XLTableRow(this, (_range.LastRowUsed(options))); + { + return new XLTableRow(this, _range.LastRowUsed(options)); + } - Int32 rowCount = _range.RowCount(); + var rowCount = _range.RowCount(); - for (Int32 ro = rowCount; ro >= 1; ro--) + for (var ro = rowCount; ro >= 1; ro--) { - var row = new XLTableRow(this, (_range.Row(ro))); + var row = new XLTableRow(this, _range.Row(ro)); if (!row.IsEmpty(options) && predicate(row)) + { return row; + } } return null; @@ -148,23 +167,25 @@ IXLTableRow IXLTableRange.Row(int row) { throw new ArgumentOutOfRangeException( nameof(row), - String.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber + RangeAddress.FirstAddress.RowNumber - 1) + string.Format("Row number must be between 1 and {0}", XLHelper.MaxRowNumber + RangeAddress.FirstAddress.RowNumber - 1) ); } return new XLTableRow(this, base.Row(row)); } - public IXLTableRows Rows(Func predicate = null) + public IXLTableRows Rows(Func predicate = null) { var retVal = new XLTableRows(Worksheet.Style); - Int32 rowCount = _range.RowCount(); + var rowCount = _range.RowCount(); - for (int r = 1; r <= rowCount; r++) + for (var r = 1; r <= rowCount; r++) { var row = Row(r); if (predicate == null || predicate(row)) + { retVal.Add(row); + } } return retVal; } @@ -173,8 +194,10 @@ public IXLTableRows Rows(Func predicate = null) { var retVal = new XLTableRows(Worksheet.Style); - for (int rowNumber = firstRow; rowNumber <= lastRow; rowNumber++) + for (var rowNumber = firstRow; rowNumber <= lastRow; rowNumber++) + { retVal.Add(Row(rowNumber)); + } return retVal; } @@ -183,10 +206,10 @@ public IXLTableRows Rows(Func predicate = null) { var retVal = new XLTableRows(Worksheet.Style); var rowPairs = rows.Split(','); - foreach (string tPair in rowPairs.Select(pair => pair.Trim())) + foreach (var tPair in rowPairs.Select(pair => pair.Trim())) { - String firstRow; - String lastRow; + string firstRow; + string lastRow; if (tPair.Contains(':') || tPair.Contains('-')) { var rowRange = XLHelper.SplitRange(tPair); @@ -199,14 +222,16 @@ public IXLTableRows Rows(Func predicate = null) firstRow = tPair; lastRow = tPair; } - foreach (IXLTableRow row in Rows(Int32.Parse(firstRow), Int32.Parse(lastRow))) + foreach (var row in Rows(int.Parse(firstRow), int.Parse(lastRow))) + { retVal.Add(row); + } } return retVal; } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLTableRows RowsUsed(Boolean includeFormats, Func predicate = null) + public IXLTableRows RowsUsed(bool includeFormats, Func predicate = null) { return RowsUsed(includeFormats ? XLCellsUsedOptions.AllContents @@ -214,53 +239,55 @@ public IXLTableRows RowsUsed(Boolean includeFormats, Func predicate); } - IXLTableRows IXLTableRange.RowsUsed(XLCellsUsedOptions options, Func predicate) + IXLTableRows IXLTableRange.RowsUsed(XLCellsUsedOptions options, Func predicate) { return RowsUsed(options, predicate); } - internal XLTableRows RowsUsed(XLCellsUsedOptions options, Func predicate = null) + internal XLTableRows RowsUsed(XLCellsUsedOptions options, Func predicate = null) { var rows = new XLTableRows(Worksheet.Style); - Int32 rowCount = RowCount(); + var rowCount = RowCount(); - for (Int32 ro = 1; ro <= rowCount; ro++) + for (var ro = 1; ro <= rowCount; ro++) { var row = Row(ro); if (!row.IsEmpty(options) && (predicate == null || predicate(row))) + { rows.Add(row); + } } return rows; } - IXLTableRows IXLTableRange.RowsUsed(Func predicate) + IXLTableRows IXLTableRange.RowsUsed(Func predicate) { return RowsUsed(predicate); } - public IXLTableRows RowsUsed(Func predicate = null) + public IXLTableRows RowsUsed(Func predicate = null) { return RowsUsed(XLCellsUsedOptions.AllContents, predicate); } - IXLTable IXLTableRange.Table { get { return _table; } } - public XLTable Table { get { return _table; } } + IXLTable IXLTableRange.Table => _table; + public XLTable Table => _table; public new IXLTableRows InsertRowsAbove(int numberOfRows) { - return XLHelper.InsertRowsWithoutEvents(base.InsertRowsAbove, this, numberOfRows, !Table.ShowTotalsRow ); + return XLHelper.InsertRowsWithoutEvents(InsertRowsAbove, this, numberOfRows, !Table.ShowTotalsRow ); } public new IXLTableRows InsertRowsBelow(int numberOfRows) { - return XLHelper.InsertRowsWithoutEvents(base.InsertRowsBelow, this, numberOfRows, !Table.ShowTotalsRow); + return XLHelper.InsertRowsWithoutEvents(InsertRowsBelow, this, numberOfRows, !Table.ShowTotalsRow); } - public new IXLRangeColumn Column(String column) + public new IXLRangeColumn Column(string column) { if (XLHelper.IsValidColumn(column)) { - Int32 coNum = XLHelper.GetColumnNumberFromLetter(column); + var coNum = XLHelper.GetColumnNumberFromLetter(column); return coNum > ColumnCount() ? Column(_table.GetFieldIndex(column) + 1) : Column(coNum); } diff --git a/ClosedXML/Excel/Tables/XLTableRow.cs b/ClosedXML/Excel/Tables/XLTableRow.cs index f863b677a..a20297ca6 100644 --- a/ClosedXML/Excel/Tables/XLTableRow.cs +++ b/ClosedXML/Excel/Tables/XLTableRow.cs @@ -1,5 +1,3 @@ -using System; - namespace ClosedXML.Excel { internal class XLTableRow : XLRangeRow, IXLTableRow @@ -14,14 +12,14 @@ public XLTableRow(XLTableRange tableRange, XLRangeRow rangeRow) #region IXLTableRow Members - public IXLCell Field(Int32 index) + public IXLCell Field(int index) { return Cell(index + 1); } - public IXLCell Field(String name) + public IXLCell Field(string name) { - Int32 fieldIndex = _tableRange.Table.GetFieldIndex(name); + var fieldIndex = _tableRange.Table.GetFieldIndex(name); return Cell(fieldIndex + 1); } @@ -30,7 +28,7 @@ public IXLCell Field(String name) return SortLeftToRight(); } - public new IXLTableRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLTableRow SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, bool ignoreBlanks = true) { base.SortLeftToRight(sortOrder, matchCase, ignoreBlanks); return this; @@ -38,7 +36,7 @@ public IXLCell Field(String name) #endregion IXLTableRow Members - private XLTableRow RowShift(Int32 rowsToShift) + private XLTableRow RowShift(int rowsToShift) { return _tableRange.Row(RowNumber() - _tableRange.FirstRow().RowNumber() + 1 + rowsToShift); } @@ -50,7 +48,7 @@ IXLTableRow IXLTableRow.RowAbove() return RowAbove(); } - IXLTableRow IXLTableRow.RowAbove(Int32 step) + IXLTableRow IXLTableRow.RowAbove(int step) { return RowAbove(step); } @@ -60,7 +58,7 @@ IXLTableRow IXLTableRow.RowAbove(Int32 step) return RowAbove(1); } - public new XLTableRow RowAbove(Int32 step) + public new XLTableRow RowAbove(int step) { return RowShift(step * -1); } @@ -74,7 +72,7 @@ IXLTableRow IXLTableRow.RowBelow() return RowBelow(); } - IXLTableRow IXLTableRow.RowBelow(Int32 step) + IXLTableRow IXLTableRow.RowBelow(int step) { return RowBelow(step); } @@ -84,7 +82,7 @@ IXLTableRow IXLTableRow.RowBelow(Int32 step) return RowBelow(1); } - public new XLTableRow RowBelow(Int32 step) + public new XLTableRow RowBelow(int step) { return RowShift(step); } @@ -99,12 +97,12 @@ IXLTableRow IXLTableRow.RowBelow(Int32 step) public new IXLTableRows InsertRowsAbove(int numberOfRows) { - return XLHelper.InsertRowsWithoutEvents(base.InsertRowsAbove, _tableRange, numberOfRows, !_tableRange.Table.ShowTotalsRow); + return XLHelper.InsertRowsWithoutEvents(InsertRowsAbove, _tableRange, numberOfRows, !_tableRange.Table.ShowTotalsRow); } public new IXLTableRows InsertRowsBelow(int numberOfRows) { - return XLHelper.InsertRowsWithoutEvents(base.InsertRowsBelow, _tableRange, numberOfRows, !_tableRange.Table.ShowTotalsRow); + return XLHelper.InsertRowsWithoutEvents(InsertRowsBelow, _tableRange, numberOfRows, !_tableRange.Table.ShowTotalsRow); } public new void Delete() diff --git a/ClosedXML/Excel/Tables/XLTableRows.cs b/ClosedXML/Excel/Tables/XLTableRows.cs index b3cff490f..7d3f747d5 100644 --- a/ClosedXML/Excel/Tables/XLTableRows.cs +++ b/ClosedXML/Excel/Tables/XLTableRows.cs @@ -1,4 +1,4 @@ -using System; +using ClosedXML.Excel.Style; using System.Collections; using System.Collections.Generic; using System.Linq; @@ -20,15 +20,17 @@ public override IEnumerable Styles get { yield return Style; - foreach (XLTableRow rng in _ranges) + foreach (var rng in _ranges) { yield return rng.Style; - foreach (XLCell r in rng.Worksheet.Internals.CellsCollection.GetCells( + foreach (var r in rng.Worksheet.Internals.CellsCollection.GetCells( rng.RangeAddress.FirstAddress.RowNumber, rng.RangeAddress.FirstAddress.ColumnNumber, rng.RangeAddress.LastAddress.RowNumber, rng.RangeAddress.LastAddress.ColumnNumber)) + { yield return r.Style; + } } } } @@ -90,20 +92,26 @@ IEnumerator IEnumerable.GetEnumerator() public IXLCells Cells() { var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - foreach (XLTableRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } public IXLCells CellsUsed() { var cells = new XLCells(true, XLCellsUsedOptions.AllContents); - foreach (XLTableRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } - public IXLCells CellsUsed(Boolean includeFormats) + public IXLCells CellsUsed(bool includeFormats) { return CellsUsed(includeFormats ? XLCellsUsedOptions.All @@ -113,8 +121,11 @@ public IXLCells CellsUsed(Boolean includeFormats) public IXLCells CellsUsed(XLCellsUsedOptions options) { var cells = new XLCells(false, options); - foreach (XLTableRow container in _ranges) + foreach (var container in _ranges) + { cells.Add(container.RangeAddress); + } + return cells; } @@ -123,7 +134,9 @@ public IXLCells CellsUsed(XLCellsUsedOptions options) public void Select() { foreach (var range in this) + { range.Select(); + } } } } diff --git a/ClosedXML/Excel/Tables/XLTableTheme.cs b/ClosedXML/Excel/Tables/XLTableTheme.cs index ca70d172d..be70807fd 100644 --- a/ClosedXML/Excel/Tables/XLTableTheme.cs +++ b/ClosedXML/Excel/Tables/XLTableTheme.cs @@ -72,17 +72,17 @@ public sealed class XLTableTheme public XLTableTheme(string name) { - this.Name = name; + Name = name; } private static IEnumerable allThemes; public static IEnumerable GetAllThemes() { - return (allThemes ?? (allThemes = typeof(XLTableTheme).GetFields(BindingFlags.Static | BindingFlags.Public) + return allThemes ??= typeof(XLTableTheme).GetFields(BindingFlags.Static | BindingFlags.Public) .Where(fi => fi.FieldType.Equals(typeof(XLTableTheme))) .Select(fi => (XLTableTheme)fi.GetValue(null)) - .ToArray())); + .ToArray(); } public static XLTableTheme FromName(string name) @@ -98,22 +98,21 @@ public override bool Equals(object obj) { return false; } - XLTableTheme theme = obj as XLTableTheme; - if (theme == null) + if (!(obj is XLTableTheme theme)) { return false; } - return this.Name.Equals(theme.Name); + return Name.Equals(theme.Name); } public override int GetHashCode() { - return this.Name.GetHashCode(); + return Name.GetHashCode(); } public override string ToString() { - return this.Name; + return Name; } #endregion Overrides diff --git a/ClosedXML/Excel/Tables/XLTables.cs b/ClosedXML/Excel/Tables/XLTables.cs index 5d2fed91c..2d384bde8 100644 --- a/ClosedXML/Excel/Tables/XLTables.cs +++ b/ClosedXML/Excel/Tables/XLTables.cs @@ -1,22 +1,22 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Collections; +using ClosedXML.Excel.Tables; namespace ClosedXML.Excel { - using System.Collections; - internal class XLTables : IXLTables { - private readonly Dictionary _tables; + private readonly Dictionary _tables; public XLTables() { - _tables = new Dictionary(StringComparer.OrdinalIgnoreCase); - Deleted = new HashSet(); + _tables = new Dictionary(StringComparer.OrdinalIgnoreCase); + Deleted = new HashSet(); } - internal ICollection Deleted { get; private set; } + internal ICollection Deleted { get; private set; } #region IXLTables Members @@ -32,7 +32,7 @@ public IXLTables Clear(XLClearOptions clearOptions = XLClearOptions.All) return this; } - public Boolean Contains(String name) + public bool Contains(string name) { return _tables.ContainsKey(name); } @@ -47,33 +47,39 @@ IEnumerator IEnumerable.GetEnumerator() return GetEnumerator(); } - public void Remove(Int32 index) + public void Remove(int index) { - this.Remove(_tables.ElementAt(index).Key); + Remove(_tables.ElementAt(index).Key); } - public void Remove(String name) + public void Remove(string name) { - if (!_tables.TryGetValue(name, out IXLTable table)) + if (!_tables.TryGetValue(name, out var table)) + { throw new ArgumentOutOfRangeException(nameof(name), $"Unable to delete table because the table name {name} could not be found."); + } _tables.Remove(name); var relId = (table as XLTable)?.RelId; if (relId != null) + { Deleted.Add(relId); + } } - public IXLTable Table(Int32 index) + public IXLTable Table(int index) { return _tables.ElementAt(index).Value; } - public IXLTable Table(String name) + public IXLTable Table(string name) { - if (TryGetTable(name, out IXLTable table)) + if (TryGetTable(name, out var table)) + { return table; + } throw new ArgumentOutOfRangeException(nameof(name), $"Table {name} was not found."); } diff --git a/ClosedXML/Excel/XLConstants.cs b/ClosedXML/Excel/XLConstants.cs index e016d0d86..43c320868 100644 --- a/ClosedXML/Excel/XLConstants.cs +++ b/ClosedXML/Excel/XLConstants.cs @@ -5,6 +5,7 @@ namespace ClosedXML.Excel public static class XLConstants { internal const int NumberOfBuiltInStyles = 164; // But they are stored as 0-based (0 - 163) + public static readonly string NewLine = "\r\n"; #region Pivot Table constants @@ -25,4 +26,4 @@ internal static class Comment internal const string ShapeTypeId = "_x0000_t202"; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/XLSheetView.cs b/ClosedXML/Excel/XLSheetView.cs index 6c6c08c38..339ad5101 100644 --- a/ClosedXML/Excel/XLSheetView.cs +++ b/ClosedXML/Excel/XLSheetView.cs @@ -22,15 +22,15 @@ public XLSheetView(XLWorksheet worksheet) public XLSheetView(XLWorksheet worksheet, XLSheetView sheetView) : this(worksheet) { - this.SplitRow = sheetView.SplitRow; - this.SplitColumn = sheetView.SplitColumn; - this.FreezePanes = sheetView.FreezePanes; - this.TopLeftCellAddress = new XLAddress(this.Worksheet, sheetView.TopLeftCellAddress.RowNumber, sheetView.TopLeftCellAddress.ColumnNumber, sheetView.TopLeftCellAddress.FixedRow, sheetView.TopLeftCellAddress.FixedColumn); + SplitRow = sheetView.SplitRow; + SplitColumn = sheetView.SplitColumn; + FreezePanes = sheetView.FreezePanes; + TopLeftCellAddress = new XLAddress(Worksheet, sheetView.TopLeftCellAddress.RowNumber, sheetView.TopLeftCellAddress.ColumnNumber, sheetView.TopLeftCellAddress.FixedRow, sheetView.TopLeftCellAddress.FixedColumn); } - public Boolean FreezePanes { get; set; } - public Int32 SplitColumn { get; set; } - public Int32 SplitRow { get; set; } + public bool FreezePanes { get; set; } + public int SplitColumn { get; set; } + public int SplitRow { get; set; } IXLAddress IXLSheetView.TopLeftCellAddress { get => TopLeftCellAddress; set => TopLeftCellAddress = (XLAddress)value; } @@ -39,8 +39,10 @@ public XLAddress TopLeftCellAddress get => _topLeftCellAddress; set { - if (value.HasWorksheet && !value.Worksheet.Equals(this.Worksheet)) + if (value.HasWorksheet && !value.Worksheet.Equals(Worksheet)) + { throw new ArgumentException($"The value should be on the same worksheet as the sheet view."); + } _topLeftCellAddress = value; } @@ -48,7 +50,7 @@ public XLAddress TopLeftCellAddress public XLSheetViewOptions View { get; set; } - IXLWorksheet IXLSheetView.Worksheet { get => Worksheet; } + IXLWorksheet IXLSheetView.Worksheet => Worksheet; public XLWorksheet Worksheet { get; internal set; } public int ZoomScale @@ -80,20 +82,20 @@ public int ZoomScale public int ZoomScaleSheetLayoutView { get; set; } - public void Freeze(Int32 rows, Int32 columns) + public void Freeze(int rows, int columns) { SplitRow = rows; SplitColumn = columns; FreezePanes = true; } - public void FreezeColumns(Int32 columns) + public void FreezeColumns(int columns) { SplitColumn = columns; FreezePanes = true; } - public void FreezeRows(Int32 rows) + public void FreezeRows(int rows) { SplitRow = rows; FreezePanes = true; diff --git a/ClosedXML/Excel/XLTheme.cs b/ClosedXML/Excel/XLTheme.cs index c8677a20f..d1cd3d2a8 100644 --- a/ClosedXML/Excel/XLTheme.cs +++ b/ClosedXML/Excel/XLTheme.cs @@ -1,6 +1,3 @@ -using System; -using System.Linq; - namespace ClosedXML.Excel { internal class XLTheme : IXLTheme diff --git a/ClosedXML/Excel/XLWorkbook.cs b/ClosedXML/Excel/XLWorkbook.cs index d2230e9b6..34089082e 100644 --- a/ClosedXML/Excel/XLWorkbook.cs +++ b/ClosedXML/Excel/XLWorkbook.cs @@ -10,7 +10,8 @@ namespace ClosedXML.Excel { - public enum XLEventTracking { Enabled, Disabled } + public enum XLEventTracking + { Enabled, Disabled } public enum XLCalculateMode { @@ -45,24 +46,12 @@ public partial class XLWorkbook : IXLWorkbook { #region Static - public static IXLStyle DefaultStyle - { - get - { - return XLStyle.Default; - } - } + public static IXLStyle DefaultStyle => XLStyle.Default; - internal static XLStyleValue DefaultStyleValue - { - get - { - return XLStyleValue.Default; - } - } + internal static XLStyleValue DefaultStyleValue => XLStyleValue.Default; - public static Double DefaultRowHeight { get; private set; } - public static Double DefaultColumnWidth { get; private set; } + public static double DefaultRowHeight { get; private set; } + public static double DefaultColumnWidth { get; private set; } public static IXLPageSetup DefaultPageOptions { @@ -91,24 +80,18 @@ public static IXLPageSetup DefaultPageOptions } } - public static IXLOutline DefaultOutline + public static IXLOutline DefaultOutline => new XLOutline(null) { - get - { - return new XLOutline(null) - { - SummaryHLocation = XLOutlineSummaryHLocation.Right, - SummaryVLocation = XLOutlineSummaryVLocation.Bottom - }; - } - } + SummaryHLocation = XLOutlineSummaryHLocation.Right, + SummaryVLocation = XLOutlineSummaryVLocation.Bottom + }; /// /// Behavior for /// public static XLCellSetValueBehavior CellSetValueBehavior { get; set; } - public static XLWorkbook OpenFromTemplate(String path) + public static XLWorkbook OpenFromTemplate(string path) { return new XLWorkbook(path, asTemplate: true); } @@ -153,7 +136,12 @@ private enum XLLoadSource /// public IXLWorksheets Worksheets { - get { return WorksheetsInternal; } + get + { + ThrowIfDisposed(); + + return WorksheetsInternal; + } } /// @@ -176,13 +164,13 @@ public IXLWorksheets Worksheets /// Gets or sets the default row height for the workbook. /// All new worksheets will use this row height. /// - public Double RowHeight { get; set; } + public double RowHeight { get; set; } /// /// Gets or sets the default column width for the workbook. /// All new worksheets will use this column width. /// - public Double ColumnWidth { get; set; } + public double ColumnWidth { get; set; } /// /// Gets or sets the default page options for the workbook. @@ -206,10 +194,10 @@ public IXLWorksheets Worksheets /// public XLCalculateMode CalculateMode { get; set; } - public Boolean CalculationOnSave { get; set; } - public Boolean ForceFullCalculation { get; set; } - public Boolean FullCalculationOnLoad { get; set; } - public Boolean FullPrecision { get; set; } + public bool CalculationOnSave { get; set; } + public bool ForceFullCalculation { get; set; } + public bool FullCalculationOnLoad { get; set; } + public bool FullPrecision { get; set; } /// /// Gets or sets the workbook's reference style. @@ -218,56 +206,32 @@ public IXLWorksheets Worksheets public IXLCustomProperties CustomProperties { get; private set; } - public Boolean ShowFormulas { get; set; } - public Boolean ShowGridLines { get; set; } - public Boolean ShowOutlineSymbols { get; set; } - public Boolean ShowRowColHeaders { get; set; } - public Boolean ShowRuler { get; set; } - public Boolean ShowWhiteSpace { get; set; } - public Boolean ShowZeros { get; set; } - public Boolean RightToLeft { get; set; } + public bool ShowFormulas { get; set; } + public bool ShowGridLines { get; set; } + public bool ShowOutlineSymbols { get; set; } + public bool ShowRowColHeaders { get; set; } + public bool ShowRuler { get; set; } + public bool ShowWhiteSpace { get; set; } + public bool ShowZeros { get; set; } + public bool RightToLeft { get; set; } - public Boolean DefaultShowFormulas - { - get { return false; } - } + public bool DefaultShowFormulas => false; - public Boolean DefaultShowGridLines - { - get { return true; } - } + public bool DefaultShowGridLines => true; - public Boolean DefaultShowOutlineSymbols - { - get { return true; } - } + public bool DefaultShowOutlineSymbols => true; - public Boolean DefaultShowRowColHeaders - { - get { return true; } - } + public bool DefaultShowRowColHeaders => true; - public Boolean DefaultShowRuler - { - get { return true; } - } + public bool DefaultShowRuler => true; - public Boolean DefaultShowWhiteSpace - { - get { return true; } - } + public bool DefaultShowWhiteSpace => true; - public Boolean DefaultShowZeros - { - get { return true; } - } + public bool DefaultShowZeros => true; public IXLFileSharing FileSharing { get; } = new XLFileSharing(); - public Boolean DefaultRightToLeft - { - get { return false; } - } + public bool DefaultRightToLeft => false; private void InitializeTheme() { @@ -288,15 +252,19 @@ private void InitializeTheme() }; } - public IXLNamedRange NamedRange(String rangeName) + public IXLNamedRange NamedRange(string rangeName) { + ThrowIfDisposed(); + + if (rangeName == null) throw new ArgumentNullException(nameof(rangeName)); + if (rangeName.Contains("!")) { var split = rangeName.Split('!'); var first = split[0]; var wsName = first.StartsWith("'") ? first.Substring(1, first.Length - 2) : first; var name = split[1]; - if (TryGetWorksheet(wsName, out IXLWorksheet ws)) + if (TryGetWorksheet(wsName, out var ws)) { var range = ws.NamedRange(name); return range ?? NamedRange(name); @@ -306,15 +274,22 @@ public IXLNamedRange NamedRange(String rangeName) return NamedRanges.NamedRange(rangeName); } - public Boolean TryGetWorksheet(String name, out IXLWorksheet worksheet) + public bool TryGetWorksheet(string name, out IXLWorksheet worksheet) { + ThrowIfDisposed(); + return Worksheets.TryGetWorksheet(name, out worksheet); } - public IXLRange RangeFromFullAddress(String rangeAddress, out IXLWorksheet ws) + public IXLRange RangeFromFullAddress(string rangeAddress, out IXLWorksheet ws) { + ThrowIfDisposed(); + ws = null; - if (!rangeAddress.Contains('!')) return null; + if (!rangeAddress.Contains('!')) + { + return null; + } var split = rangeAddress.Split('!'); var wsName = split[0].UnescapeSheetName(); @@ -325,10 +300,15 @@ public IXLRange RangeFromFullAddress(String rangeAddress, out IXLWorksheet ws) return null; } - public IXLCell CellFromFullAddress(String cellAddress, out IXLWorksheet ws) + public IXLCell CellFromFullAddress(string cellAddress, out IXLWorksheet ws) { + ThrowIfDisposed(); + ws = null; - if (!cellAddress.Contains('!')) return null; + if (!cellAddress.Contains('!')) + { + return null; + } var split = cellAddress.Split('!'); var wsName = split[0].UnescapeSheetName(); @@ -344,6 +324,8 @@ public IXLCell CellFromFullAddress(String cellAddress, out IXLWorksheet ws) /// public void Save() { + ThrowIfDisposed(); + #if DEBUG Save(true, false); #else @@ -354,8 +336,10 @@ public void Save() /// /// Saves the current workbook and optionally performs validation /// - public void Save(Boolean validate, Boolean evaluateFormulae = false) + public void Save(bool validate, bool evaluateFormulae = false) { + ThrowIfDisposed(); + Save(new SaveOptions { ValidatePackage = validate, @@ -366,23 +350,31 @@ public void Save(Boolean validate, Boolean evaluateFormulae = false) public void Save(SaveOptions options) { - checkForWorksheetsPresent(); + ThrowIfDisposed(); + + CheckForWorksheetsPresent(); if (_loadSource == XLLoadSource.New) + { throw new InvalidOperationException("This is a new file. Please use one of the 'SaveAs' methods."); + } if (_loadSource == XLLoadSource.Stream) { CreatePackage(_originalStream, false, _spreadsheetDocumentType, options); } else + { CreatePackage(_originalFile, _spreadsheetDocumentType, options); + } } /// /// Saves the current workbook to a file. /// - public void SaveAs(String file) + public void SaveAs(string file) { + ThrowIfDisposed(); + #if DEBUG SaveAs(file, true, false); #else @@ -393,8 +385,10 @@ public void SaveAs(String file) /// /// Saves the current workbook to a file and optionally validates it. /// - public void SaveAs(String file, Boolean validate, Boolean evaluateFormulae = false) + public void SaveAs(string file, bool validate, bool evaluateFormulae = false) { + ThrowIfDisposed(); + SaveAs(file, new SaveOptions { ValidatePackage = validate, @@ -403,23 +397,33 @@ public void SaveAs(String file, Boolean validate, Boolean evaluateFormulae = fal }); } - public void SaveAs(String file, SaveOptions options) + public void SaveAs(string file, SaveOptions options) { - checkForWorksheetsPresent(); + ThrowIfDisposed(); + + CheckForWorksheetsPresent(); + + if (options == null) throw new ArgumentNullException(nameof(options)); + if (file == null) throw new ArgumentNullException(nameof(file)); var directoryName = Path.GetDirectoryName(file); - if (!string.IsNullOrWhiteSpace(directoryName)) Directory.CreateDirectory(directoryName); + if (!string.IsNullOrWhiteSpace(directoryName)) + { + Directory.CreateDirectory(directoryName); + } if (_loadSource == XLLoadSource.New) { if (File.Exists(file)) + { File.Delete(file); + } CreatePackage(file, GetSpreadsheetDocumentType(file), options); } else if (_loadSource == XLLoadSource.File) { - if (String.Compare(_originalFile.Trim(), file.Trim(), true) != 0) + if (string.Compare(_originalFile.Trim(), file.Trim(), true, CultureInfo.InvariantCulture) != 0) { File.Copy(_originalFile, file, true); File.SetAttributes(file, FileAttributes.Normal); @@ -431,11 +435,9 @@ public void SaveAs(String file, SaveOptions options) { _originalStream.Position = 0; - using (var fileStream = File.Create(file)) - { - CopyStream(_originalStream, fileStream); - CreatePackage(fileStream, false, _spreadsheetDocumentType, options); - } + using var fileStream = File.Create(file); + CopyStream(_originalStream, fileStream); + CreatePackage(fileStream, false, _spreadsheetDocumentType, options); } _loadSource = XLLoadSource.File; @@ -447,32 +449,29 @@ private static SpreadsheetDocumentType GetSpreadsheetDocumentType(string filePat { var extension = Path.GetExtension(filePath); - if (string.IsNullOrEmpty(extension)) throw new ArgumentException("Empty extension is not supported."); - extension = extension.Substring(1).ToLowerInvariant(); - - switch (extension) + if (string.IsNullOrEmpty(extension)) { - case "xlsm": - return SpreadsheetDocumentType.MacroEnabledWorkbook; - - case "xltm": - return SpreadsheetDocumentType.MacroEnabledTemplate; - - case "xlsx": - return SpreadsheetDocumentType.Workbook; + throw new ArgumentException("Empty extension is not supported."); + } - case "xltx": - return SpreadsheetDocumentType.Template; + extension = extension.Substring(1).ToUpperInvariant(); - default: - throw new ArgumentException(String.Format("Extension '{0}' is not supported. Supported extensions are '.xlsx', '.xlsm', '.xltx' and '.xltm'.", extension)); - } + return extension switch + { + "XLSM" => SpreadsheetDocumentType.MacroEnabledWorkbook, + "XLTM" => SpreadsheetDocumentType.MacroEnabledTemplate, + "XLSX" => SpreadsheetDocumentType.Workbook, + "XLTX" => SpreadsheetDocumentType.Template, + _ => throw new ArgumentException(string.Format("Extension '{0}' is not supported. Supported extensions are '.xlsx', '.xlsm', '.xltx' and '.xltm'.", extension)), + }; } - private void checkForWorksheetsPresent() + private void CheckForWorksheetsPresent() { if (!Worksheets.Any()) + { throw new InvalidOperationException("Workbooks need at least one worksheet."); + } } /// @@ -480,6 +479,8 @@ private void checkForWorksheetsPresent() /// public void SaveAs(Stream stream) { + ThrowIfDisposed(); + #if DEBUG SaveAs(stream, true, false); #else @@ -490,8 +491,10 @@ public void SaveAs(Stream stream) /// /// Saves the current workbook to a stream and optionally validates it. /// - public void SaveAs(Stream stream, Boolean validate, Boolean evaluateFormulae = false) + public void SaveAs(Stream stream, bool validate, bool evaluateFormulae = false) { + ThrowIfDisposed(); + SaveAs(stream, new SaveOptions { ValidatePackage = validate, @@ -502,12 +505,14 @@ public void SaveAs(Stream stream, Boolean validate, Boolean evaluateFormulae = f public void SaveAs(Stream stream, SaveOptions options) { - checkForWorksheetsPresent(); + ThrowIfDisposed(); + + CheckForWorksheetsPresent(); if (_loadSource == XLLoadSource.New) { // dm 20130422, this method or better the method SpreadsheetDocument.Create which is called // inside of 'CreatePackage' need a stream which CanSeek & CanRead - // and an ordinary Response stream of a webserver can't do this + // and an ordinary Response stream of a web-server can't do this // so we have to ask and provide a way around this if (stream.CanRead && stream.CanSeek && stream.CanWrite) { @@ -517,15 +522,13 @@ public void SaveAs(Stream stream, SaveOptions options) else { // the harder way - using (var ms = new MemoryStream()) - { - CreatePackage(ms, true, _spreadsheetDocumentType, options); - // not really nessesary, because I changed CopyStream too. - // but for better understanding and if somebody in the future - // provide an changed version of CopyStream - ms.Position = 0; - CopyStream(ms, stream); - } + using var ms = new MemoryStream(); + CreatePackage(ms, true, _spreadsheetDocumentType, options); + // not really nessesary, because I changed CopyStream too. + // but for better understanding and if somebody in the future + // provide an changed version of CopyStream + ms.Position = 0; + CopyStream(ms, stream); } } else if (_loadSource == XLLoadSource.File) @@ -540,7 +543,9 @@ public void SaveAs(Stream stream, SaveOptions options) { _originalStream.Position = 0; if (_originalStream != stream) + { CopyStream(_originalStream, stream); + } CreatePackage(stream, false, _spreadsheetDocumentType, options); } @@ -556,72 +561,99 @@ internal static void CopyStream(Stream input, Stream output) int len; // dm 20130422, it is always a good idea to rewind the input stream, or not? if (input.CanSeek) + { input.Seek(0, SeekOrigin.Begin); + } + while ((len = input.Read(buffer, 0, buffer.Length)) > 0) + { output.Write(buffer, 0, len); + } // dm 20130422, and flushing the output after write output.Flush(); } public IXLTable Table(string tableName, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase) { - var table = this.Worksheets + ThrowIfDisposed(); + + var table = Worksheets .SelectMany(ws => ws.Tables) .FirstOrDefault(t => t.Name.Equals(tableName, comparisonType)); if (table == null) + { throw new ArgumentOutOfRangeException($"Table {tableName} was not found."); + } return table; } - public IXLWorksheet Worksheet(String name) + public IXLWorksheet Worksheet(string name) { + ThrowIfDisposed(); + return WorksheetsInternal.Worksheet(name); } - public IXLWorksheet Worksheet(Int32 position) + public IXLWorksheet Worksheet(int position) { + ThrowIfDisposed(); + return WorksheetsInternal.Worksheet(position); } - public IXLCustomProperty CustomProperty(String name) + public IXLCustomProperty CustomProperty(string name) { + ThrowIfDisposed(); + return CustomProperties.CustomProperty(name); } - public IXLCells FindCells(Func predicate) + public IXLCells FindCells(Func predicate) { + ThrowIfDisposed(); + var cells = new XLCells(false, XLCellsUsedOptions.AllContents); - foreach (XLWorksheet ws in WorksheetsInternal) + foreach (var ws in WorksheetsInternal) { foreach (XLCell cell in ws.CellsUsed(XLCellsUsedOptions.All)) { if (predicate(cell)) + { cells.Add(cell); + } } } return cells; } - public IXLRows FindRows(Func predicate) + public IXLRows FindRows(Func predicate) { + ThrowIfDisposed(); + var rows = new XLRows(worksheet: null); - foreach (XLWorksheet ws in WorksheetsInternal) + foreach (var ws in WorksheetsInternal) { - foreach (IXLRow row in ws.Rows().Where(predicate)) + foreach (var row in ws.Rows().Where(predicate)) + { rows.Add(row as XLRow); + } } return rows; } - public IXLColumns FindColumns(Func predicate) + public IXLColumns FindColumns(Func predicate) { + ThrowIfDisposed(); + var columns = new XLColumns(worksheet: null); - foreach (XLWorksheet ws in WorksheetsInternal) + foreach (var ws in WorksheetsInternal) { - foreach (IXLColumn column in ws.Columns().Where(predicate)) + foreach (var column in ws.Columns().Where(predicate)) + { columns.Add(column as XLColumn); + } } return columns; } @@ -633,19 +665,23 @@ public IXLColumns FindColumns(Func predicate) /// The compare options. /// if set to true search formulae instead of cell values. /// - public IEnumerable Search(String searchText, CompareOptions compareOptions = CompareOptions.Ordinal, Boolean searchFormulae = false) + public IEnumerable Search(string searchText, CompareOptions compareOptions = CompareOptions.Ordinal, bool searchFormulae = false) { + ThrowIfDisposed(); + foreach (var ws in WorksheetsInternal) { foreach (var cell in ws.Search(searchText, compareOptions, searchFormulae)) + { yield return cell; + } } } #region Fields private XLLoadSource _loadSource = XLLoadSource.New; - private String _originalFile; + private string _originalFile; private Stream _originalStream; private XLWorkbookProtection _workbookProtection; @@ -661,7 +697,7 @@ public XLWorkbook() { } - internal XLWorkbook(String file, Boolean asTemplate) + internal XLWorkbook(string file, bool asTemplate) : this(XLEventTracking.Enabled) { LoadSheetsFromTemplate(file); @@ -706,12 +742,12 @@ public XLWorkbook(LoadOptions loadOptions) /// Opens an existing workbook from a file. /// /// The file to open. - public XLWorkbook(String file) + public XLWorkbook(string file) : this(file, XLEventTracking.Enabled) { } - public XLWorkbook(String file, XLEventTracking eventTracking) + public XLWorkbook(string file, XLEventTracking eventTracking) : this(eventTracking) { _loadSource = XLLoadSource.File; @@ -720,11 +756,13 @@ public XLWorkbook(String file, XLEventTracking eventTracking) Load(file); } - public XLWorkbook(String file, LoadOptions loadOptions) + public XLWorkbook(string file, LoadOptions loadOptions) : this(file, loadOptions.EventTracking) { if (loadOptions.RecalculateAllFormulas) - this.RecalculateAllFormulas(); + { + RecalculateAllFormulas(); + } } /// @@ -748,7 +786,9 @@ public XLWorkbook(Stream stream, LoadOptions loadOptions) : this(stream, loadOptions.EventTracking) { if (loadOptions.RecalculateAllFormulas) - this.RecalculateAllFormulas(); + { + RecalculateAllFormulas(); + } } #endregion Constructor @@ -757,40 +797,54 @@ public XLWorkbook(Stream stream, LoadOptions loadOptions) internal sealed class UnsupportedSheet { - public Boolean IsActive; - public UInt32 SheetId; - public Int32 Position; + public bool IsActive; + public uint SheetId; + public int Position; } #endregion Nested type: UnsupportedSheet - public IXLCell Cell(String namedCell) + public IXLCell Cell(string namedCell) { + ThrowIfDisposed(); + var namedRange = NamedRange(namedCell); if (namedRange != null) { return namedRange.Ranges?.FirstOrDefault()?.FirstCell(); } else + { return CellFromFullAddress(namedCell, out _); + } } - public IXLCells Cells(String namedCells) + public IXLCells Cells(string namedCells) { + ThrowIfDisposed(); + return Ranges(namedCells).Cells(); } - public IXLRange Range(String range) + public IXLRange Range(string range) { + ThrowIfDisposed(); + var namedRange = NamedRange(range); if (namedRange != null) + { return namedRange.Ranges.FirstOrDefault(); + } else + { return RangeFromFullAddress(range, out _); + } } - public IXLRanges Ranges(String ranges) + public IXLRanges Ranges(string ranges) { + ThrowIfDisposed(); + var retVal = new XLRanges(); var rangePairs = ranges.Split(','); foreach (var range in rangePairs.Select(r => Range(r.Trim())).Where(range => range != null)) @@ -802,89 +856,87 @@ public IXLRanges Ranges(String ranges) internal XLIdManager ShapeIdManager { get; private set; } - // Used by Janitor.Fody - private void DisposeManaged() - { - Worksheets.ForEach(w => (w as XLWorksheet).Cleanup()); - } - -#if _NET40_ - public void Dispose() - { - // net40 doesn't support Janitor.Fody, so let's dispose manually - DisposeManaged(); - } -#else - - public void Dispose() - { - // Leave this empty (for non net40 targets) so that Janitor.Fody can do its work - } - -#endif - - public Boolean Use1904DateSystem { get; set; } + public bool Use1904DateSystem { get; set; } public XLWorkbook SetUse1904DateSystem() { + ThrowIfDisposed(); + return SetUse1904DateSystem(true); } - public XLWorkbook SetUse1904DateSystem(Boolean value) + public XLWorkbook SetUse1904DateSystem(bool value) { + ThrowIfDisposed(); + Use1904DateSystem = value; return this; } public IXLWorksheet AddWorksheet() { + ThrowIfDisposed(); + return Worksheets.Add(); } - public IXLWorksheet AddWorksheet(Int32 position) + public IXLWorksheet AddWorksheet(int position) { + ThrowIfDisposed(); + return Worksheets.Add(position); } - public IXLWorksheet AddWorksheet(String sheetName) + public IXLWorksheet AddWorksheet(string sheetName) { + ThrowIfDisposed(); + return Worksheets.Add(sheetName); } - public IXLWorksheet AddWorksheet(String sheetName, Int32 position) + public IXLWorksheet AddWorksheet(string sheetName, int position) { + ThrowIfDisposed(); + return Worksheets.Add(sheetName, position); } public IXLWorksheet AddWorksheet(DataTable dataTable) { + ThrowIfDisposed(); + return Worksheets.Add(dataTable); } public void AddWorksheet(DataSet dataSet) { + ThrowIfDisposed(); + Worksheets.Add(dataSet); } public void AddWorksheet(IXLWorksheet worksheet) { + ThrowIfDisposed(); + worksheet.CopyTo(this, worksheet.Name); } - public IXLWorksheet AddWorksheet(DataTable dataTable, String sheetName) + public IXLWorksheet AddWorksheet(DataTable dataTable, string sheetName) { + ThrowIfDisposed(); + return Worksheets.Add(dataTable, sheetName); } private XLCalcEngine _calcEngine; - private XLCalcEngine CalcEngine - { - get { return _calcEngine ?? (_calcEngine = new XLCalcEngine(this)); } - } + private XLCalcEngine CalcEngine => _calcEngine ??= new XLCalcEngine(this); - public Object Evaluate(String expression) + public object Evaluate(string expression) { + ThrowIfDisposed(); + return CalcEngine.Evaluate(expression); } @@ -893,61 +945,74 @@ public Object Evaluate(String expression) /// public void RecalculateAllFormulas() { + ThrowIfDisposed(); + InvalidateFormulas(); Worksheets.ForEach(sheet => sheet.RecalculateAllFormulas()); } + private readonly SpreadsheetDocumentType _spreadsheetDocumentType; + private static XLCalcEngine _calcEngineExpr; - private SpreadsheetDocumentType _spreadsheetDocumentType; + private bool disposed; - private static XLCalcEngine CalcEngineExpr - { - get { return _calcEngineExpr ?? (_calcEngineExpr = new XLCalcEngine()); } - } + private static XLCalcEngine CalcEngineExpr => _calcEngineExpr ??= new XLCalcEngine(); - public static Object EvaluateExpr(String expression) + public static object EvaluateExpr(string expression) { return CalcEngineExpr.Evaluate(expression); } - public String Author { get; set; } + public string Author { get; set; } - public Boolean LockStructure + public bool LockStructure { get => Protection.IsProtected && !Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Structure); set { + ThrowIfDisposed(); + if (!Protection.IsProtected) + { throw new InvalidOperationException($"Enable workbook protection before setting the {nameof(LockStructure)} property"); + } Protection.AllowElement(XLWorkbookProtectionElements.Structure, value); } } - public XLWorkbook SetLockStructure(Boolean value) + public XLWorkbook SetLockStructure(bool value) { + ThrowIfDisposed(); + LockStructure = value; return this; } - public Boolean LockWindows + public bool LockWindows { get => Protection.IsProtected && !Protection.AllowedElements.HasFlag(XLWorkbookProtectionElements.Windows); set { + ThrowIfDisposed(); + if (!Protection.IsProtected) + { throw new InvalidOperationException($"Enable workbook protection before setting the {nameof(LockWindows)} property"); + } Protection.AllowElement(XLWorkbookProtectionElements.Windows, value); } } - public XLWorkbook SetLockWindows(Boolean value) + public XLWorkbook SetLockWindows(bool value) { + ThrowIfDisposed(); + LockWindows = value; return this; } - public Boolean IsPasswordProtected => Protection.IsPasswordProtected; - public Boolean IsProtected => Protection.IsProtected; + public bool IsPasswordProtected => Protection.IsPasswordProtected; + public bool IsProtected => Protection.IsProtected; IXLWorkbookProtection IXLProtectable.Protection { @@ -960,81 +1025,110 @@ internal XLWorkbookProtection Protection get => _workbookProtection; set { + ThrowIfDisposed(); + _workbookProtection = value.Clone().CastTo(); } } [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - public IXLWorkbookProtection Protect(Boolean lockStructure, Boolean lockWindows, String password) + public IXLWorkbookProtection Protect(bool lockStructure, bool lockWindows, string password) { + ThrowIfDisposed(); + var allowedElements = XLWorkbookProtectionElements.Everything; var protection = Protection.Protect(password, DefaultProtectionAlgorithm, allowedElements); if (lockStructure) + { protection.DisallowElement(XLWorkbookProtectionElements.Structure); + } if (lockWindows) + { protection.DisallowElement(XLWorkbookProtectionElements.Windows); + } return protection; } public IXLWorkbookProtection Protect() { + ThrowIfDisposed(); + return Protection.Protect(); } [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - public IXLWorkbookProtection Protect(Boolean lockStructure) + public IXLWorkbookProtection Protect(bool lockStructure) { + ThrowIfDisposed(); + return Protect(lockStructure, lockWindows: false, password: null); } [Obsolete("Use Protect(String password, Algorithm algorithm, TElement allowedElements)")] - public IXLWorkbookProtection Protect(Boolean lockStructure, Boolean lockWindows) + public IXLWorkbookProtection Protect(bool lockStructure, bool lockWindows) { + ThrowIfDisposed(); + return Protect(lockStructure, lockWindows, null); } - public IXLWorkbookProtection Protect(String password, Algorithm algorithm = DefaultProtectionAlgorithm) - + public IXLWorkbookProtection Protect(string password, Algorithm algorithm = DefaultProtectionAlgorithm) { + ThrowIfDisposed(); + return Protect(password, algorithm, XLWorkbookProtectionElements.Windows); } - public IXLWorkbookProtection Protect(String password, Algorithm algorithm, XLWorkbookProtectionElements allowedElements) + public IXLWorkbookProtection Protect(string password, Algorithm algorithm, XLWorkbookProtectionElements allowedElements) { + ThrowIfDisposed(); + return Protection.Protect(password, algorithm, allowedElements); } IXLElementProtection IXLProtectable.Protect() { + ThrowIfDisposed(); + return Protect(); } IXLElementProtection IXLProtectable.Protect(string password, Algorithm algorithm) { + ThrowIfDisposed(); + return Protect(password, algorithm); } public IXLWorkbookProtection Unprotect() { + ThrowIfDisposed(); + return Protection.Unprotect(); } - public IXLWorkbookProtection Unprotect(String password) + public IXLWorkbookProtection Unprotect(string password) { + ThrowIfDisposed(); + return Protection.Unprotect(password); } IXLElementProtection IXLProtectable.Unprotect() { + ThrowIfDisposed(); + return Unprotect(); } - IXLElementProtection IXLProtectable.Unprotect(String password) + IXLElementProtection IXLProtectable.Unprotect(string password) { + ThrowIfDisposed(); + return Unprotect(password); } @@ -1046,18 +1140,20 @@ public override string ToString() return "XLWorkbook(new)"; case XLLoadSource.File: - return String.Format("XLWorkbook({0})", _originalFile); + return $"XLWorkbook({_originalFile})"; case XLLoadSource.Stream: - return String.Format("XLWorkbook({0})", _originalStream.ToString()); + return $"XLWorkbook({_originalStream})"; default: - throw new NotImplementedException(); + return nameof(XLWorkbook); } } public void SuspendEvents() { + ThrowIfDisposed(); + foreach (var ws in WorksheetsInternal) { ws.SuspendEvents(); @@ -1066,10 +1162,39 @@ public void SuspendEvents() public void ResumeEvents() { + ThrowIfDisposed(); + foreach (var ws in WorksheetsInternal) { ws.ResumeEvents(); } } + + private void ThrowIfDisposed() + { + if (disposed) + { + throw new ObjectDisposedException("TemplateClass"); + } + } + + protected virtual void Dispose(bool disposing) + { + if (!disposed) + { + if (disposing) + { + Worksheets?.ForEach(w => (w as XLWorksheet)?.Cleanup()); + } + + disposed = true; + } + } + + public void Dispose() + { + Dispose(disposing: true); + GC.SuppressFinalize(this); + } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/XLWorkbookProperties.cs b/ClosedXML/Excel/XLWorkbookProperties.cs index e9d2bcb32..a225cea94 100644 --- a/ClosedXML/Excel/XLWorkbookProperties.cs +++ b/ClosedXML/Excel/XLWorkbookProperties.cs @@ -9,17 +9,17 @@ public XLWorkbookProperties() Company = null; Manager = null; } - public String Author { get; set; } - public String Title { get; set; } - public String Subject { get; set; } - public String Category { get; set; } - public String Keywords { get; set; } - public String Comments { get; set; } - public String Status { get; set; } + public string Author { get; set; } + public string Title { get; set; } + public string Subject { get; set; } + public string Category { get; set; } + public string Keywords { get; set; } + public string Comments { get; set; } + public string Status { get; set; } public DateTime Created { get; set; } public DateTime Modified { get; set; } - public String LastModifiedBy { get; set; } - public String Company { get; set; } - public String Manager { get; set; } + public string LastModifiedBy { get; set; } + public string Company { get; set; } + public string Manager { get; set; } } } diff --git a/ClosedXML/Excel/XLWorkbook_ImageHandling.cs b/ClosedXML/Excel/XLWorkbook_ImageHandling.cs index 8ea8d2916..ca99e7d0d 100644 --- a/ClosedXML/Excel/XLWorkbook_ImageHandling.cs +++ b/ClosedXML/Excel/XLWorkbook_ImageHandling.cs @@ -4,8 +4,6 @@ using System; using System.Linq; -using Xdr = DocumentFormat.OpenXml.Drawing.Spreadsheet; - namespace ClosedXML.Excel { public partial class XLWorkbook @@ -14,59 +12,74 @@ public static OpenXmlElement GetAnchorFromImageId(WorksheetPart worksheetPart, s { var drawingsPart = worksheetPart.DrawingsPart; var matchingAnchor = drawingsPart.WorksheetDrawing - .Where(wsdr => wsdr.Descendants() + .Where(wsdr => wsdr.Descendants() .Any(x => x?.Blip?.Embed?.Value.Equals(relId) ?? false) ); if (!matchingAnchor.Any()) + { return null; + } else + { return matchingAnchor.First(); + } } - public static OpenXmlElement GetAnchorFromImageIndex(WorksheetPart worksheetPart, Int32 index) + public static OpenXmlElement GetAnchorFromImageIndex(WorksheetPart worksheetPart, int index) { var drawingsPart = worksheetPart.DrawingsPart; var matchingAnchor = drawingsPart.WorksheetDrawing - .Where(wsdr => wsdr.Descendants() + .Where(wsdr => wsdr.Descendants() .Any(x => x.Id.Value.Equals(Convert.ToUInt32(index + 1))) ); if (!matchingAnchor.Any()) + { return null; + } else + { return matchingAnchor.First(); + } } public static NonVisualDrawingProperties GetPropertiesFromAnchor(OpenXmlElement anchor) { if (!IsAllowedAnchor(anchor)) + { return null; + } // Maybe we should not restrict here, and just search for all NonVisualDrawingProperties in an anchor? - var shape = anchor.Descendants().Cast().FirstOrDefault() - ?? anchor.Descendants().Cast().FirstOrDefault(); + var shape = anchor.Descendants().Cast().FirstOrDefault() + ?? anchor.Descendants().Cast().FirstOrDefault(); - if (shape == null) return null; + if (shape == null) + { + return null; + } return shape - .Descendants() + .Descendants() .FirstOrDefault(); } - public static String GetImageRelIdFromAnchor(OpenXmlElement anchor) + public static string GetImageRelIdFromAnchor(OpenXmlElement anchor) { if (!IsAllowedAnchor(anchor)) + { return null; + } - var blipFill = anchor.Descendants().FirstOrDefault(); + var blipFill = anchor.Descendants().FirstOrDefault(); return blipFill?.Blip?.Embed?.Value; } private static bool IsAllowedAnchor(OpenXmlElement anchor) { var allowedAnchorTypes = new Type[] { typeof(AbsoluteAnchor), typeof(OneCellAnchor), typeof(TwoCellAnchor) }; - return (allowedAnchorTypes.Any(t => t == anchor.GetType())); + return allowedAnchorTypes.Any(t => t == anchor.GetType()); } } } diff --git a/ClosedXML/Excel/XLWorkbook_Load.cs b/ClosedXML/Excel/XLWorkbook_Load.cs index 65e29b404..b8a2785b3 100644 --- a/ClosedXML/Excel/XLWorkbook_Load.cs +++ b/ClosedXML/Excel/XLWorkbook_Load.cs @@ -1,8 +1,13 @@ +using ClosedXML.Excel.Drawings; +using ClosedXML.Excel.Tables; using ClosedXML.Extensions; using ClosedXML.Utils; using DocumentFormat.OpenXml; +using DocumentFormat.OpenXml.CustomProperties; +using DocumentFormat.OpenXml.ExtendedProperties; using DocumentFormat.OpenXml.Packaging; using DocumentFormat.OpenXml.Spreadsheet; +using SkiaSharp; using System; using System.Collections.Generic; using System.Globalization; @@ -11,23 +16,15 @@ using System.Text; using System.Text.RegularExpressions; using System.Xml.Linq; -using Ap = DocumentFormat.OpenXml.ExtendedProperties; -using Op = DocumentFormat.OpenXml.CustomProperties; -using X14 = DocumentFormat.OpenXml.Office2010.Excel; using Xdr = DocumentFormat.OpenXml.Drawing.Spreadsheet; namespace ClosedXML.Excel { - using Ap; - using Drawings; - using Op; - using System.Drawing; - public partial class XLWorkbook { - private readonly Dictionary _colorList = new Dictionary(); + private readonly Dictionary _colorList = new Dictionary(); - private void Load(String file) + private void Load(string file) { LoadSheets(file); } @@ -37,22 +34,24 @@ private void Load(Stream stream) LoadSheets(stream); } - private void LoadSheets(String fileName) + private void LoadSheets(string fileName) { - using (var dSpreadsheet = SpreadsheetDocument.Open(fileName, false)) - LoadSpreadsheetDocument(dSpreadsheet); + using var dSpreadsheet = SpreadsheetDocument.Open(fileName, false); + LoadSpreadsheetDocument(dSpreadsheet); } private void LoadSheets(Stream stream) { - using (var dSpreadsheet = SpreadsheetDocument.Open(stream, false)) - LoadSpreadsheetDocument(dSpreadsheet); + using var dSpreadsheet = SpreadsheetDocument.Open(stream, false); + LoadSpreadsheetDocument(dSpreadsheet); } - private void LoadSheetsFromTemplate(String fileName) + private void LoadSheetsFromTemplate(string fileName) { using (var dSpreadsheet = SpreadsheetDocument.CreateFromTemplate(fileName)) + { LoadSpreadsheetDocument(dSpreadsheet); + } // If we load a workbook as a template, we have to treat it as a "new" workbook. // The original file will NOT be copied into place before changes are applied @@ -75,10 +74,14 @@ private void ResetAllRelIds() } foreach (var picture in ws.Pictures.Cast()) + { picture.RelId = null; + } foreach (var table in ws.Tables.Cast()) + { table.RelId = null; + } } } @@ -98,13 +101,17 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { foreach (var m in dSpreadsheet.CustomFilePropertiesPart.Properties.Elements()) { - String name = m.Name?.Value; + var name = m.Name?.Value; if (string.IsNullOrWhiteSpace(name)) + { continue; + } if (m.VTLPWSTR != null) + { CustomProperties.Add(name, m.VTLPWSTR.Text); + } else if (m.VTFileTime != null) { CustomProperties.Add(name, @@ -112,15 +119,21 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) CultureInfo.InvariantCulture)); } else if (m.VTDouble != null) - CustomProperties.Add(name, Double.Parse(m.VTDouble.Text, CultureInfo.InvariantCulture)); + { + CustomProperties.Add(name, double.Parse(m.VTDouble.Text, CultureInfo.InvariantCulture)); + } else if (m.VTBool != null) + { CustomProperties.Add(name, m.VTBool.Text == "true"); + } } } var wbProps = dSpreadsheet.WorkbookPart.Workbook.WorkbookProperties; if (wbProps != null) + { Use1904DateSystem = OpenXmlHelper.GetBooleanValueAsBool(wbProps.Date1904, false); + } var wbFilesharing = dSpreadsheet.WorkbookPart.Workbook.FileSharing; if (wbFilesharing != null) @@ -136,37 +149,53 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { var calculateMode = calculationProperties.CalculationMode; if (calculateMode != null) + { CalculateMode = calculateMode.Value.ToClosedXml(); + } var calculationOnSave = calculationProperties.CalculationOnSave; if (calculationOnSave != null) + { CalculationOnSave = calculationOnSave.Value; + } var forceFullCalculation = calculationProperties.ForceFullCalculation; if (forceFullCalculation != null) + { ForceFullCalculation = forceFullCalculation.Value; + } var fullCalculationOnLoad = calculationProperties.FullCalculationOnLoad; if (fullCalculationOnLoad != null) + { FullCalculationOnLoad = fullCalculationOnLoad.Value; + } var fullPrecision = calculationProperties.FullPrecision; if (fullPrecision != null) + { FullPrecision = fullPrecision.Value; + } var referenceMode = calculationProperties.ReferenceMode; if (referenceMode != null) + { ReferenceStyle = referenceMode.Value.ToClosedXml(); + } } var efp = dSpreadsheet.ExtendedFilePropertiesPart; if (efp != null && efp.Properties != null) { if (efp.Properties.Elements().Any()) + { Properties.Company = efp.Properties.GetFirstChild().Text; + } if (efp.Properties.Elements().Any()) + { Properties.Manager = efp.Properties.GetFirstChild().Text; + } } Stylesheet s = null; @@ -176,27 +205,29 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) s = dSpreadsheet.WorkbookPart.WorkbookStylesPart.Stylesheet; } - NumberingFormats numberingFormats = s == null ? null : s.NumberingFormats; - Fills fills = s == null ? null : s.Fills; - Borders borders = s == null ? null : s.Borders; - Fonts fonts = s == null ? null : s.Fonts; - Int32 dfCount = 0; - Dictionary differentialFormats; + var numberingFormats = s?.NumberingFormats; + var fills = s?.Fills; + var borders = s?.Borders; + var fonts = s?.Fonts; + var dfCount = 0; + Dictionary differentialFormats; if (s != null && s.DifferentialFormats != null) + { differentialFormats = s.DifferentialFormats.Elements().ToDictionary(k => dfCount++); + } else - differentialFormats = new Dictionary(); + { + differentialFormats = new Dictionary(); + } var sheets = dSpreadsheet.WorkbookPart.Workbook.Sheets; - Int32 position = 0; + var position = 0; foreach (var dSheet in sheets.OfType()) { position++; - var sharedFormulasR1C1 = new Dictionary(); - - var worksheetPart = dSpreadsheet.WorkbookPart.GetPartById(dSheet.Id) as WorksheetPart; + var sharedFormulasR1C1 = new Dictionary(); - if (worksheetPart == null) + if (!(dSpreadsheet.WorkbookPart.GetPartById(dSheet.Id) is WorksheetPart worksheetPart)) { UnsupportedSheets.Add(new UnsupportedSheet { SheetId = dSheet.SheetId.Value, Position = position }); continue; @@ -206,10 +237,12 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) var ws = (XLWorksheet)WorksheetsInternal.Add(sheetName, position); ws.RelId = dSheet.Id; - ws.SheetId = (Int32)dSheet.SheetId.Value; + ws.SheetId = (int)dSheet.SheetId.Value; if (dSheet.State != null) + { ws.Visibility = dSheet.State.Value.ToClosedXml(); + } ApplyStyle(ws, 0, s, fills, borders, fonts, numberingFormats); @@ -220,7 +253,7 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) using (var reader = OpenXmlReader.Create(worksheetPart)) { - Type[] ignoredElements = new Type[] + var ignoredElements = new Type[] { typeof(CustomSheetViews) // Custom sheet views contain its own auto filter data, and more, which should be ignored for now }; @@ -228,7 +261,9 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) while (reader.Read()) { while (ignoredElements.Contains(reader.ElementType)) + { reader.ReadNextSibling(); + } if (reader.ElementType == typeof(SheetFormatProperties)) { @@ -236,10 +271,12 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) if (sheetFormatProperties != null) { if (sheetFormatProperties.DefaultRowHeight != null) + { ws.RowHeight = sheetFormatProperties.DefaultRowHeight; + } - ws.RowHeightChanged = (sheetFormatProperties.CustomHeight != null && - sheetFormatProperties.CustomHeight.Value); + ws.RowHeightChanged = sheetFormatProperties.CustomHeight != null && + sheetFormatProperties.CustomHeight.Value; if (sheetFormatProperties.DefaultColumnWidth != null) { @@ -248,52 +285,86 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) } } else if (reader.ElementType == typeof(SheetViews)) + { LoadSheetViews((SheetViews)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(MergeCells)) { var mergedCells = (MergeCells)reader.LoadCurrentElement(); if (mergedCells != null) { - foreach (MergeCell mergeCell in mergedCells.Elements()) + foreach (var mergeCell in mergedCells.Elements()) + { ws.Range(mergeCell.Reference).Merge(false); + } } } else if (reader.ElementType == typeof(Columns)) + { LoadColumns(s, numberingFormats, fills, borders, fonts, ws, (Columns)reader.LoadCurrentElement()); + } else if (reader.ElementType == typeof(Row)) { LoadRows(s, numberingFormats, fills, borders, fonts, ws, sharedStrings, sharedFormulasR1C1, styleList, (Row)reader.LoadCurrentElement()); } else if (reader.ElementType == typeof(AutoFilter)) + { LoadAutoFilter((AutoFilter)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(SheetProtection)) + { LoadSheetProtection((SheetProtection)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(DataValidations)) + { LoadDataValidations((DataValidations)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(ConditionalFormatting)) + { LoadConditionalFormatting((ConditionalFormatting)reader.LoadCurrentElement(), ws, differentialFormats); + } else if (reader.ElementType == typeof(Hyperlinks)) + { LoadHyperlinks((Hyperlinks)reader.LoadCurrentElement(), worksheetPart, ws); + } else if (reader.ElementType == typeof(PrintOptions)) + { LoadPrintOptions((PrintOptions)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(PageMargins)) + { LoadPageMargins((PageMargins)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(PageSetup)) + { LoadPageSetup((PageSetup)reader.LoadCurrentElement(), ws, pageSetupProperties); + } else if (reader.ElementType == typeof(HeaderFooter)) + { LoadHeaderFooter((HeaderFooter)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(SheetProperties)) + { LoadSheetProperties((SheetProperties)reader.LoadCurrentElement(), ws, out pageSetupProperties); + } else if (reader.ElementType == typeof(RowBreaks)) + { LoadRowBreaks((RowBreaks)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(ColumnBreaks)) + { LoadColumnBreaks((ColumnBreaks)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(WorksheetExtensionList)) + { LoadExtensions((WorksheetExtensionList)reader.LoadCurrentElement(), ws); + } else if (reader.ElementType == typeof(LegacyDrawing)) + { ws.LegacyDrawingId = (reader.LoadCurrentElement() as LegacyDrawing).Id.Value; + } } reader.Close(); } @@ -307,10 +378,12 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) var relId = worksheetPart.GetIdOfPart(tableDefinitionPart); var dTable = tableDefinitionPart.Table; - String reference = dTable.Reference.Value; - String tableName = dTable.Name ?? dTable.DisplayName ?? string.Empty; - if (String.IsNullOrWhiteSpace(tableName)) + var reference = dTable.Reference.Value; + string tableName = dTable.Name ?? dTable.DisplayName ?? string.Empty; + if (string.IsNullOrWhiteSpace(tableName)) + { throw new InvalidDataException("The table name is missing."); + } var xlTable = ws.Range(reference).CreateTable(tableName, false) as XLTable; xlTable.RelId = relId; @@ -327,28 +400,48 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) } if (dTable.TotalsRowCount != null && dTable.TotalsRowCount.Value > 0) - ((XLTable)xlTable)._showTotalsRow = true; + { + xlTable._showTotalsRow = true; + } if (dTable.TableStyleInfo != null) { if (dTable.TableStyleInfo.ShowFirstColumn != null) + { xlTable.EmphasizeFirstColumn = dTable.TableStyleInfo.ShowFirstColumn.Value; + } + if (dTable.TableStyleInfo.ShowLastColumn != null) + { xlTable.EmphasizeLastColumn = dTable.TableStyleInfo.ShowLastColumn.Value; + } + if (dTable.TableStyleInfo.ShowRowStripes != null) + { xlTable.ShowRowStripes = dTable.TableStyleInfo.ShowRowStripes.Value; + } + if (dTable.TableStyleInfo.ShowColumnStripes != null) + { xlTable.ShowColumnStripes = dTable.TableStyleInfo.ShowColumnStripes.Value; + } + if (dTable.TableStyleInfo.Name != null) { var theme = XLTableTheme.FromName(dTable.TableStyleInfo.Name.Value); if (theme != null) + { xlTable.Theme = theme; + } else + { xlTable.Theme = new XLTableTheme(dTable.TableStyleInfo.Name.Value); + } } else + { xlTable.Theme = XLTableTheme.None; + } } if (dTable.AutoFilter != null) @@ -357,7 +450,9 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) LoadAutoFilterColumns(dTable.AutoFilter, xlTable.AutoFilter); } else + { xlTable.ShowAutoFilter = false; + } if (xlTable.ShowTotalsRow) { @@ -365,23 +460,33 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { var tableColumnName = GetTableColumnName(tableColumn.Name.Value); if (tableColumn.TotalsRowFunction != null) + { xlTable.Field(tableColumnName).TotalsRowFunction = tableColumn.TotalsRowFunction.Value.ToClosedXml(); + } if (tableColumn.TotalsRowFormula != null) + { xlTable.Field(tableColumnName).TotalsRowFormulaA1 = tableColumn.TotalsRowFormula.Text; + } if (tableColumn.TotalsRowLabel != null) + { xlTable.Field(tableColumnName).TotalsRowLabel = tableColumn.TotalsRowLabel.Value; + } } if (xlTable.AutoFilter != null) + { xlTable.AutoFilter.Range = xlTable.Worksheet.Range( xlTable.RangeAddress.FirstAddress.RowNumber, xlTable.RangeAddress.FirstAddress.ColumnNumber, xlTable.RangeAddress.LastAddress.RowNumber - 1, xlTable.RangeAddress.LastAddress.ColumnNumber); + } } else if (xlTable.AutoFilter != null) + { xlTable.AutoFilter.Range = xlTable.Worksheet.Range(xlTable.RangeAddress); + } } #endregion LoadTables @@ -405,16 +510,20 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) XElement shape = null; if (i < shapes.Count) + { shape = shapes[i]; + } // find cell by reference var cell = ws.Cell(c.Reference); var shapeIdString = shape?.Attribute("id")?.Value; if (shapeIdString?.StartsWith("_x0000_s") ?? false) + { shapeIdString = shapeIdString.Substring(8); + } - int? shapeId = int.TryParse(shapeIdString, out int sid) ? (int?)sid : null; + var shapeId = int.TryParse(shapeIdString, out var sid) ? (int?)sid : null; var xlComment = cell.CreateComment(shapeId); xlComment.Author = authors[(int)c.AuthorId.Value].InnerText; @@ -424,11 +533,17 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) foreach (var run in runs) { var runProperties = run.RunProperties; - String text = run.Text.InnerText.FixNewLines(); + var text = run.Text.InnerText.FixNewLines(); var rt = xlComment.AddText(text); LoadFont(runProperties, rt); } + var texts = c.GetFirstChild().Elements(); + foreach (var text in texts) + { + xlComment.AddText(text.InnerText.FixNewLines()); + } + if (shape != null) { LoadShapeProperties(xlComment, shape); @@ -436,11 +551,17 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) var clientData = shape.Elements().First(e => e.Name.LocalName == "ClientData"); LoadClientData(xlComment, clientData); - var textBox = shape.Elements().First(e => e.Name.LocalName == "textbox"); - LoadTextBox(xlComment, textBox); + var textBox = shape.Elements().FirstOrDefault(e => e.Name.LocalName == "textbox"); + if (textBox != null) + { + LoadTextBox(xlComment, textBox); + } var alt = shape.Attribute("alt"); - if (alt != null) xlComment.Style.Web.SetAlternateText(alt.Value); + if (alt != null) + { + xlComment.Style.Web.SetAlternateText(alt.Value); + } LoadColorsAndLines(xlComment, shape); @@ -464,13 +585,15 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) } else { - UnsupportedSheet unsupportedSheet = - UnsupportedSheets.FirstOrDefault(us => us.Position == (Int32)(workbookView.ActiveTab.Value + 1)); + var unsupportedSheet = + UnsupportedSheets.FirstOrDefault(us => us.Position == (int)(workbookView.ActiveTab.Value + 1)); if (unsupportedSheet != null) + { unsupportedSheet.IsActive = true; + } else { - Worksheet((Int32)(workbookView.ActiveTab.Value + 1)).SetTabActive(); + Worksheet((int)(workbookView.ActiveTab.Value + 1)).SetTabActive(); } } } @@ -481,9 +604,7 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) // Delay loading of pivot tables until all sheets have been loaded foreach (var dSheet in sheets.OfType()) { - var worksheetPart = dSpreadsheet.WorkbookPart.GetPartById(dSheet.Id) as WorksheetPart; - - if (worksheetPart != null) + if (dSpreadsheet.WorkbookPart.GetPartById(dSheet.Id) is WorksheetPart worksheetPart) { var ws = (XLWorksheet)WorksheetsInternal.Worksheet(dSheet.Name); @@ -500,14 +621,14 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) } IXLRange source = null; - XLPivotTableSourceType sourceType = XLPivotTableSourceType.Range; + var sourceType = XLPivotTableSourceType.Range; if (pivotTableCacheDefinitionPart?.PivotCacheDefinition?.CacheSource?.WorksheetSource != null) { // TODO: Implement other sources besides worksheetSource // But for now assume names and references point directly to a range var wss = pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheSource.WorksheetSource; - if (!String.IsNullOrEmpty(wss.Id)) + if (!string.IsNullOrEmpty(wss.Id)) { var externalRelationship = pivotTableCacheDefinitionPart.ExternalRelationships.FirstOrDefault(er => er.Id.Equals(wss.Id)); if (externalRelationship?.IsExternal ?? false) @@ -533,7 +654,7 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) else { sourceType = XLPivotTableSourceType.Range; - source = this.Range(wss.Name.Value); + source = Range(wss.Name.Value); } } else @@ -542,13 +663,19 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) IXLWorksheet sourceSheet; if (wss.Sheet == null) + { sourceSheet = ws; + } else if (WorksheetsInternal.TryGetWorksheet(wss.Sheet.Value, out sourceSheet)) - source = this.Range(sourceSheet.Range(wss.Reference.Value).RangeAddress.ToStringRelative(includeSheet: true)); + { + source = Range(sourceSheet.Range(wss.Reference.Value).RangeAddress.ToStringRelative(includeSheet: true)); + } } if (source == null) + { continue; + } } if (target != null && source != null) @@ -568,72 +695,204 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) throw new NotSupportedException($"Pivot table source type {sourceType} is not supported."); } - if (!String.IsNullOrWhiteSpace(StringValue.ToString(pivotTableDefinition?.ColumnHeaderCaption ?? String.Empty))) + if (!string.IsNullOrWhiteSpace(StringValue.ToString(pivotTableDefinition?.ColumnHeaderCaption ?? string.Empty))) + { pt.SetColumnHeaderCaption(StringValue.ToString(pivotTableDefinition.ColumnHeaderCaption)); + } - if (!String.IsNullOrWhiteSpace(StringValue.ToString(pivotTableDefinition?.RowHeaderCaption ?? String.Empty))) + if (!string.IsNullOrWhiteSpace(StringValue.ToString(pivotTableDefinition?.RowHeaderCaption ?? string.Empty))) + { pt.SetRowHeaderCaption(StringValue.ToString(pivotTableDefinition.RowHeaderCaption)); + } pt.RelId = worksheetPart.GetIdOfPart(pivotTablePart); pt.CacheDefinitionRelId = pivotTablePart.GetIdOfPart(pivotTableCacheDefinitionPart); pt.WorkbookCacheRelId = dSpreadsheet.WorkbookPart.GetIdOfPart(pivotTableCacheDefinitionPart); - if (pivotTableDefinition.MergeItem != null) pt.MergeAndCenterWithLabels = pivotTableDefinition.MergeItem.Value; - if (pivotTableDefinition.Indent != null) pt.RowLabelIndent = (int)pivotTableDefinition.Indent.Value; - if (pivotTableDefinition.PageOverThenDown != null) pt.FilterAreaOrder = pivotTableDefinition.PageOverThenDown.Value ? XLFilterAreaOrder.OverThenDown : XLFilterAreaOrder.DownThenOver; - if (pivotTableDefinition.PageWrap != null) pt.FilterFieldsPageWrap = (int)pivotTableDefinition.PageWrap.Value; - if (pivotTableDefinition.UseAutoFormatting != null) pt.AutofitColumns = pivotTableDefinition.UseAutoFormatting.Value; - if (pivotTableDefinition.PreserveFormatting != null) pt.PreserveCellFormatting = pivotTableDefinition.PreserveFormatting.Value; - if (pivotTableDefinition.RowGrandTotals != null) pt.ShowGrandTotalsRows = pivotTableDefinition.RowGrandTotals.Value; - if (pivotTableDefinition.ColumnGrandTotals != null) pt.ShowGrandTotalsColumns = pivotTableDefinition.ColumnGrandTotals.Value; - if (pivotTableDefinition.SubtotalHiddenItems != null) pt.FilteredItemsInSubtotals = pivotTableDefinition.SubtotalHiddenItems.Value; - if (pivotTableDefinition.MultipleFieldFilters != null) pt.AllowMultipleFilters = pivotTableDefinition.MultipleFieldFilters.Value; - if (pivotTableDefinition.CustomListSort != null) pt.UseCustomListsForSorting = pivotTableDefinition.CustomListSort.Value; - if (pivotTableDefinition.ShowDrill != null) pt.ShowExpandCollapseButtons = pivotTableDefinition.ShowDrill.Value; - if (pivotTableDefinition.ShowDataTips != null) pt.ShowContextualTooltips = pivotTableDefinition.ShowDataTips.Value; - if (pivotTableDefinition.ShowMemberPropertyTips != null) pt.ShowPropertiesInTooltips = pivotTableDefinition.ShowMemberPropertyTips.Value; - if (pivotTableDefinition.ShowHeaders != null) pt.DisplayCaptionsAndDropdowns = pivotTableDefinition.ShowHeaders.Value; - if (pivotTableDefinition.GridDropZones != null) pt.ClassicPivotTableLayout = pivotTableDefinition.GridDropZones.Value; - if (pivotTableDefinition.ShowEmptyRow != null) pt.ShowEmptyItemsOnRows = pivotTableDefinition.ShowEmptyRow.Value; - if (pivotTableDefinition.ShowEmptyColumn != null) pt.ShowEmptyItemsOnColumns = pivotTableDefinition.ShowEmptyColumn.Value; - if (pivotTableDefinition.ShowItems != null) pt.DisplayItemLabels = pivotTableDefinition.ShowItems.Value; - if (pivotTableDefinition.FieldListSortAscending != null) pt.SortFieldsAtoZ = pivotTableDefinition.FieldListSortAscending.Value; - if (pivotTableDefinition.PrintDrill != null) pt.PrintExpandCollapsedButtons = pivotTableDefinition.PrintDrill.Value; - if (pivotTableDefinition.ItemPrintTitles != null) pt.RepeatRowLabels = pivotTableDefinition.ItemPrintTitles.Value; - if (pivotTableDefinition.FieldPrintTitles != null) pt.PrintTitles = pivotTableDefinition.FieldPrintTitles.Value; - if (pivotTableDefinition.EnableDrill != null) pt.EnableShowDetails = pivotTableDefinition.EnableDrill.Value; - if (pivotTableCacheDefinitionPart.PivotCacheDefinition.SaveData != null) pt.SaveSourceData = pivotTableCacheDefinitionPart.PivotCacheDefinition.SaveData.Value; + if (pivotTableDefinition.MergeItem != null) + { + pt.MergeAndCenterWithLabels = pivotTableDefinition.MergeItem.Value; + } + + if (pivotTableDefinition.Indent != null) + { + pt.RowLabelIndent = (int)pivotTableDefinition.Indent.Value; + } + + if (pivotTableDefinition.PageOverThenDown != null) + { + pt.FilterAreaOrder = pivotTableDefinition.PageOverThenDown.Value ? XLFilterAreaOrder.OverThenDown : XLFilterAreaOrder.DownThenOver; + } + + if (pivotTableDefinition.PageWrap != null) + { + pt.FilterFieldsPageWrap = (int)pivotTableDefinition.PageWrap.Value; + } + + if (pivotTableDefinition.UseAutoFormatting != null) + { + pt.AutofitColumns = pivotTableDefinition.UseAutoFormatting.Value; + } + + if (pivotTableDefinition.PreserveFormatting != null) + { + pt.PreserveCellFormatting = pivotTableDefinition.PreserveFormatting.Value; + } + + if (pivotTableDefinition.RowGrandTotals != null) + { + pt.ShowGrandTotalsRows = pivotTableDefinition.RowGrandTotals.Value; + } + + if (pivotTableDefinition.ColumnGrandTotals != null) + { + pt.ShowGrandTotalsColumns = pivotTableDefinition.ColumnGrandTotals.Value; + } + + if (pivotTableDefinition.SubtotalHiddenItems != null) + { + pt.FilteredItemsInSubtotals = pivotTableDefinition.SubtotalHiddenItems.Value; + } + + if (pivotTableDefinition.MultipleFieldFilters != null) + { + pt.AllowMultipleFilters = pivotTableDefinition.MultipleFieldFilters.Value; + } + + if (pivotTableDefinition.CustomListSort != null) + { + pt.UseCustomListsForSorting = pivotTableDefinition.CustomListSort.Value; + } + + if (pivotTableDefinition.ShowDrill != null) + { + pt.ShowExpandCollapseButtons = pivotTableDefinition.ShowDrill.Value; + } + + if (pivotTableDefinition.ShowDataTips != null) + { + pt.ShowContextualTooltips = pivotTableDefinition.ShowDataTips.Value; + } + + if (pivotTableDefinition.ShowMemberPropertyTips != null) + { + pt.ShowPropertiesInTooltips = pivotTableDefinition.ShowMemberPropertyTips.Value; + } + + if (pivotTableDefinition.ShowHeaders != null) + { + pt.DisplayCaptionsAndDropdowns = pivotTableDefinition.ShowHeaders.Value; + } + + if (pivotTableDefinition.GridDropZones != null) + { + pt.ClassicPivotTableLayout = pivotTableDefinition.GridDropZones.Value; + } + + if (pivotTableDefinition.ShowEmptyRow != null) + { + pt.ShowEmptyItemsOnRows = pivotTableDefinition.ShowEmptyRow.Value; + } + + if (pivotTableDefinition.ShowEmptyColumn != null) + { + pt.ShowEmptyItemsOnColumns = pivotTableDefinition.ShowEmptyColumn.Value; + } + + if (pivotTableDefinition.ShowItems != null) + { + pt.DisplayItemLabels = pivotTableDefinition.ShowItems.Value; + } + + if (pivotTableDefinition.FieldListSortAscending != null) + { + pt.SortFieldsAtoZ = pivotTableDefinition.FieldListSortAscending.Value; + } + + if (pivotTableDefinition.PrintDrill != null) + { + pt.PrintExpandCollapsedButtons = pivotTableDefinition.PrintDrill.Value; + } + + if (pivotTableDefinition.ItemPrintTitles != null) + { + pt.RepeatRowLabels = pivotTableDefinition.ItemPrintTitles.Value; + } + + if (pivotTableDefinition.FieldPrintTitles != null) + { + pt.PrintTitles = pivotTableDefinition.FieldPrintTitles.Value; + } + + if (pivotTableDefinition.EnableDrill != null) + { + pt.EnableShowDetails = pivotTableDefinition.EnableDrill.Value; + } + + if (pivotTableCacheDefinitionPart.PivotCacheDefinition.SaveData != null) + { + pt.SaveSourceData = pivotTableCacheDefinitionPart.PivotCacheDefinition.SaveData.Value; + } + + if (pivotTableDefinition.DataCaption != null) + { + pt.DataCaption = pivotTableDefinition.DataCaption.Value; + } + + if (pivotTableDefinition.GrandTotalCaption != null) + { + pt.GrandTotalCaption = pivotTableDefinition.GrandTotalCaption.Value; + } if (pivotTableCacheDefinitionPart.PivotCacheDefinition.MissingItemsLimit != null) { if (pivotTableCacheDefinitionPart.PivotCacheDefinition.MissingItemsLimit == 0U) + { pt.ItemsToRetainPerField = XLItemsToRetain.None; + } else if (pivotTableCacheDefinitionPart.PivotCacheDefinition.MissingItemsLimit == XLHelper.MaxRowNumber) + { pt.ItemsToRetainPerField = XLItemsToRetain.Max; + } } if (pivotTableDefinition.ShowMissing != null && pivotTableDefinition.MissingCaption != null) + { pt.EmptyCellReplacement = pivotTableDefinition.MissingCaption.Value; + } if (pivotTableDefinition.ShowError != null && pivotTableDefinition.ErrorCaption != null) + { pt.ErrorValueReplacement = pivotTableDefinition.ErrorCaption.Value; + } var pivotTableDefinitionExtensionList = pivotTableDefinition.GetFirstChild(); var pivotTableDefinitionExtension = pivotTableDefinitionExtensionList?.GetFirstChild(); var pivotTableDefinition2 = pivotTableDefinitionExtension?.GetFirstChild(); if (pivotTableDefinition2 != null) { - if (pivotTableDefinition2.EnableEdit != null) pt.EnableCellEditing = pivotTableDefinition2.EnableEdit.Value; - if (pivotTableDefinition2.HideValuesRow != null) pt.ShowValuesRow = !pivotTableDefinition2.HideValuesRow.Value; + if (pivotTableDefinition2.EnableEdit != null) + { + pt.EnableCellEditing = pivotTableDefinition2.EnableEdit.Value; + } + + if (pivotTableDefinition2.HideValuesRow != null) + { + pt.ShowValuesRow = !pivotTableDefinition2.HideValuesRow.Value; + } } var pivotTableStyle = pivotTableDefinition.GetFirstChild(); if (pivotTableStyle != null) { if (pivotTableStyle.Name != null) + { pt.Theme = (XLPivotTableTheme)Enum.Parse(typeof(XLPivotTableTheme), pivotTableStyle.Name); + } else + { pt.Theme = XLPivotTableTheme.None; + } pt.ShowRowHeaders = OpenXmlHelper.GetBooleanValueAsBool(pivotTableStyle.ShowRowHeaders, false); pt.ShowColumnHeaders = OpenXmlHelper.GetBooleanValueAsBool(pivotTableStyle.ShowColumnHeaders, false); @@ -644,12 +903,18 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) // Subtotal configuration if (pivotTableDefinition.PivotFields.Cast().All(pf => (pf.DefaultSubtotal == null || pf.DefaultSubtotal.Value) && (pf.SubtotalTop == null || pf.SubtotalTop == true))) + { pt.SetSubtotals(XLPivotSubtotals.AtTop); + } else if (pivotTableDefinition.PivotFields.Cast().All(pf => (pf.DefaultSubtotal == null || pf.DefaultSubtotal.Value) - && (pf.SubtotalTop != null && pf.SubtotalTop.Value == false))) + && pf.SubtotalTop != null && pf.SubtotalTop.Value == false)) + { pt.SetSubtotals(XLPivotSubtotals.AtBottom); + } else + { pt.SetSubtotals(XLPivotSubtotals.DoNotShow); + } // Row labels if (pivotTableDefinition.RowFields != null) @@ -660,20 +925,27 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { IXLPivotField pivotField = null; if (rf.Index.Value == -2) + { pivotField = pt.RowLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); + } else { - var pf = pivotTableDefinition.PivotFields.ElementAt(rf.Index.Value) as PivotField; - if (pf == null) + if (!(pivotTableDefinition.PivotFields.ElementAt(rf.Index.Value) is PivotField pf)) + { continue; + } var cacheField = pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheFields.ElementAt(rf.Index.Value) as CacheField; if (pt.SourceRangeFieldsAvailable.Contains(cacheField.Name?.Value)) + { pivotField = pf.Name != null ? pt.RowLabels.Add(cacheField.Name, pf.Name.Value) : pt.RowLabels.Add(cacheField.Name.Value); + } else + { continue; + } if (pivotField != null) { @@ -697,20 +969,27 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { IXLPivotField pivotField = null; if (cf.Index.Value == -2) + { pivotField = pt.ColumnLabels.Add(XLConstants.PivotTable.ValuesSentinalLabel); + } else if (cf.Index < pivotTableDefinition.PivotFields.Count) { - var pf = pivotTableDefinition.PivotFields.ElementAt(cf.Index.Value) as PivotField; - if (pf == null) + if (!(pivotTableDefinition.PivotFields.ElementAt(cf.Index.Value) is PivotField pf)) + { continue; + } var cacheField = pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheFields.ElementAt(cf.Index.Value) as CacheField; if (pt.SourceRangeFieldsAvailable.Contains(cacheField.Name?.Value)) + { pivotField = pf.Name != null ? pt.ColumnLabels.Add(cacheField.Name, pf.Name.Value) : pt.ColumnLabels.Add(cacheField.Name.Value); + } else + { continue; + } if (pivotField != null) { @@ -733,24 +1012,41 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { IXLPivotValue pivotValue = null; if ((int)df.Field.Value == -2) + { pivotValue = pt.Values.Add(XLConstants.PivotTable.ValuesSentinalLabel); + } else if (df.Field.Value < pivotTableDefinition.PivotFields.Count) { - var pf = pivotTableDefinition.PivotFields.ElementAt((int)df.Field.Value) as PivotField; - if (pf == null) + if (!(pivotTableDefinition.PivotFields.ElementAt((int)df.Field.Value) is PivotField pf)) + { continue; + } var cacheField = pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheFields.ElementAt((int)df.Field.Value) as CacheField; if (pf.Name != null) + { pivotValue = pt.Values.Add(pf.Name.Value, df.Name.Value); - else if (cacheField.Name != null && pt.SourceRangeFieldsAvailable.Contains(cacheField.Name)) + } + else if (cacheField.Name != null && pt.SourceRangeFieldsAvailable.Contains(cacheField.Name)) + { pivotValue = pt.Values.Add(cacheField.Name.Value, df.Name.Value); + } else + { continue; + } + + if (df.NumberFormatId != null) + { + pivotValue.NumberFormat.SetNumberFormatId((int)df.NumberFormatId.Value); + } + + if (df.Subtotal != null) + { + pivotValue = pivotValue.SetSummaryFormula(df.Subtotal.Value.ToClosedXml()); + } - if (df.NumberFormatId != null) pivotValue.NumberFormat.SetNumberFormatId((int)df.NumberFormatId.Value); - if (df.Subtotal != null) pivotValue = pivotValue.SetSummaryFormula(df.Subtotal.Value.ToClosedXml()); if (df.ShowDataAs != null) { var calculation = df.ShowDataAs.Value.ToClosedXml(); @@ -772,7 +1068,9 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { var bi = (int)df.BaseItem.Value; if (bi.Between(0, items.Count - 1)) + { pivotValue.BaseItem = items[(int)df.BaseItem.Value].ToString(); + } } } } @@ -784,29 +1082,38 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) { foreach (var pageField in pivotTableDefinition.PageFields.Cast()) { - var pf = pivotTableDefinition.PivotFields.ElementAt(pageField.Field.Value) as PivotField; - if (pf == null) + if (!(pivotTableDefinition.PivotFields.ElementAt(pageField.Field.Value) is PivotField pf)) + { continue; + } var cacheField = pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheFields.ElementAt(pageField.Field.Value) as CacheField; if (!pt.SourceRangeFieldsAvailable.Contains(cacheField.Name?.Value)) + { continue; + } var filterName = pf.Name?.Value ?? cacheField.Name?.Value; IXLPivotField rf; if (pageField.Name?.Value != null) + { rf = pt.ReportFilters.Add(filterName, pageField.Name.Value); + } else + { rf = pt.ReportFilters.Add(filterName); + } var openXmlItems = new List(); if ((pageField.Item?.HasValue ?? false) && pf.Items.Any() && cacheField.SharedItems.Any()) { if (!(pf.Items.ElementAt(Convert.ToInt32(pageField.Item.Value)) is Item item)) + { continue; + } openXmlItems.Add(item); } @@ -864,23 +1171,29 @@ private void LoadSpreadsheetDocument(SpreadsheetDocument dSpreadsheet) #endregion Pivot tables } - private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, PivotCacheDefinition pcd, Dictionary differentialFormats) + private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, PivotCacheDefinition pcd, Dictionary differentialFormats) { if (ptd.Formats == null) + { return; + } foreach (var format in ptd.Formats.OfType()) { var pivotArea = format.PivotArea; if (pivotArea == null) + { continue; + } var type = pivotArea.Type ?? PivotAreaValues.Normal; var dataOnly = OpenXmlHelper.GetBooleanValueAsBool(pivotArea.DataOnly, true); var labelOnly = OpenXmlHelper.GetBooleanValueAsBool(pivotArea.LabelOnly, false); if (dataOnly && labelOnly) + { throw new InvalidOperationException("Cannot have dataOnly and labelOnly both set to true."); + } XLPivotStyleFormat styleFormat; @@ -892,53 +1205,75 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi var appliesTo = XLPivotStyleFormatElement.All; if (dataOnly) + { appliesTo = XLPivotStyleFormatElement.Data; + } else if (labelOnly) + { appliesTo = XLPivotStyleFormatElement.Label; + } var isRow = OpenXmlHelper.GetBooleanValueAsBool(pivotArea.GrandRow, false); var isColumn = OpenXmlHelper.GetBooleanValueAsBool(pivotArea.GrandColumn, false); // Either of the two should be true, else this is an unsupported format if (!isRow && !isColumn) + { continue; + } //throw new NotImplementedException(); if (isRow) + { styleFormat = pt.StyleFormats.RowGrandTotalFormats.ForElement(appliesTo) as XLPivotStyleFormat; + } else + { styleFormat = pt.StyleFormats.ColumnGrandTotalFormats.ForElement(appliesTo) as XLPivotStyleFormat; + } } else { - Int32 fieldIndex; - Boolean defaultSubtotal = false; + int fieldIndex; + var defaultSubtotal = false; if (pivotArea.Field != null) - fieldIndex = (Int32)pivotArea.Field; + { + fieldIndex = (int)pivotArea.Field; + } else if (pivotArea.PivotAreaReferences?.OfType()?.Any() ?? false) { // The field we want does NOT have any children var r = pivotArea.PivotAreaReferences.OfType().FirstOrDefault(r1 => !r1.Any()); if (r == null) + { continue; + } - fieldIndex = Convert.ToInt32((UInt32)r.Field); + fieldIndex = Convert.ToInt32((uint)r.Field); defaultSubtotal = OpenXmlHelper.GetBooleanValueAsBool(r.DefaultSubtotal, false); } else + { throw new NotImplementedException(); + } XLPivotField field = null; if (fieldIndex == -2) { var axis = pivotArea.Axis.Value; if (axis == PivotTableAxisValues.AxisRow) + { field = (XLPivotField)pt.RowLabels.Single(f => f.SourceName == "{{Values}}"); + } else if (axis == PivotTableAxisValues.AxisColumn) + { field = (XLPivotField)pt.ColumnLabels.Single(f => f.SourceName == "{{Values}}"); + } else + { continue; + } } else { @@ -946,7 +1281,9 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi field = (XLPivotField)pt.ImplementedFields.SingleOrDefault(f => f.SourceName.Equals(fieldName)); if (field is null) + { continue; + } } if (defaultSubtotal) @@ -1000,7 +1337,9 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi { fieldIndex = unchecked((int)reference.Field.Value); if (field.Offset == fieldIndex) + { continue; // already handled + } var fieldItem = reference.OfType().First(); var fieldItemValue = (int)fieldItem.Val.Value; @@ -1020,7 +1359,7 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi var cacheField = pcd.CacheFields.OfType() .FirstOrDefault(cf => cf.Name == additionalFieldName); - Predicate predicate = null; + Predicate predicate = null; if ((cacheField?.SharedItems?.Any() ?? false) && fieldItemValue < cacheField.SharedItems.Count) { @@ -1043,7 +1382,7 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi IXLStyle style = XLStyle.Default; if (format.FormatId != null) { - var df = differentialFormats[(Int32)format.FormatId.Value]; + var df = differentialFormats[(int)format.FormatId.Value]; LoadFont(df.Font, style.Font); LoadFill(df.Fill, style.Fill, differentialFillFormat: true); LoadBorder(df.Border, style.Border); @@ -1056,52 +1395,120 @@ private void LoadPivotStyleFormats(XLPivotTable pt, PivotTableDefinition ptd, Pi private static void LoadFieldOptions(PivotField pf, IXLPivotField pivotField) { - if (pf.SubtotalCaption != null) pivotField.SubtotalCaption = pf.SubtotalCaption; - if (pf.IncludeNewItemsInFilter != null) pivotField.IncludeNewItemsInFilter = pf.IncludeNewItemsInFilter.Value; - if (pf.Outline != null) pivotField.Outline = pf.Outline.Value; - if (pf.Compact != null) pivotField.Compact = pf.Compact.Value; - if (pf.InsertBlankRow != null) pivotField.InsertBlankLines = pf.InsertBlankRow.Value; + if (pf.SubtotalCaption != null) + { + pivotField.SubtotalCaption = pf.SubtotalCaption; + } + + if (pf.IncludeNewItemsInFilter != null) + { + pivotField.IncludeNewItemsInFilter = pf.IncludeNewItemsInFilter.Value; + } + + if (pf.Outline != null) + { + pivotField.Outline = pf.Outline.Value; + } + + if (pf.Compact != null) + { + pivotField.Compact = pf.Compact.Value; + } + + if (pf.InsertBlankRow != null) + { + pivotField.InsertBlankLines = pf.InsertBlankRow.Value; + } + pivotField.ShowBlankItems = OpenXmlHelper.GetBooleanValueAsBool(pf.ShowAll, true); - if (pf.InsertPageBreak != null) pivotField.InsertPageBreaks = pf.InsertPageBreak.Value; - if (pf.SubtotalTop != null) pivotField.SubtotalsAtTop = pf.SubtotalTop.Value; - if (pf.AllDrilled != null) pivotField.Collapsed = !pf.AllDrilled.Value; + if (pf.InsertPageBreak != null) + { + pivotField.InsertPageBreaks = pf.InsertPageBreak.Value; + } + + if (pf.SubtotalTop != null) + { + pivotField.SubtotalsAtTop = pf.SubtotalTop.Value; + } + + if (pf.AllDrilled != null) + { + pivotField.Collapsed = !pf.AllDrilled.Value; + } var pivotFieldExtensionList = pf.GetFirstChild(); var pivotFieldExtension = pivotFieldExtensionList?.GetFirstChild(); var field2010 = pivotFieldExtension?.GetFirstChild(); - if (field2010?.FillDownLabels != null) pivotField.RepeatItemLabels = field2010.FillDownLabels.Value; + if (field2010?.FillDownLabels != null) + { + pivotField.RepeatItemLabels = field2010.FillDownLabels.Value; + } } private static void LoadSubtotals(PivotField pf, IXLPivotField pivotField) { if (pf.AverageSubTotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Average); + } + if (pf.CountASubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Count); + } + if (pf.CountSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.CountNumbers); + } + if (pf.MaxSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Maximum); + } + if (pf.MinSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Minimum); + } + if (pf.ApplyStandardDeviationPInSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.PopulationStandardDeviation); + } + if (pf.ApplyVariancePInSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.PopulationVariance); + } + if (pf.ApplyProductInSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Product); + } + if (pf.ApplyStandardDeviationInSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.StandardDeviation); + } + if (pf.SumSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Sum); + } + if (pf.ApplyVarianceInSubtotal != null) + { pivotField.AddSubtotal(XLSubtotalFunction.Variance); + } if (pf.Items?.Any() ?? false) { var items = pf.Items.OfType().Where(i => i.Index != null && i.Index.HasValue); if (!items.Any(i => i.HideDetails == null || BooleanValue.ToBoolean(i.HideDetails))) + { pivotField.SetCollapsed(); + } } } @@ -1116,73 +1523,78 @@ private void LoadDrawings(WorksheetPart wsPart, IXLWorksheet ws) var imgId = GetImageRelIdFromAnchor(anchor); //If imgId is null, we're probably dealing with a TextBox (or another shape) instead of a picture - if (imgId == null) continue; + if (imgId == null) + { + continue; + } var imagePart = drawingsPart.GetPartById(imgId); - using (var stream = imagePart.GetStream()) - using (var ms = new MemoryStream()) - { - stream.CopyTo(ms); - var vsdp = GetPropertiesFromAnchor(anchor); + using var stream = imagePart.GetStream(); + using var ms = new MemoryStream(); + stream.CopyTo(ms); + var vsdp = GetPropertiesFromAnchor(anchor); - var picture = (ws as XLWorksheet).AddPicture(ms, vsdp.Name, Convert.ToInt32(vsdp.Id.Value)) as XLPicture; - picture.RelId = imgId; + var picture = (ws as XLWorksheet).AddPicture(ms, vsdp.Name, Convert.ToInt32(vsdp.Id.Value)) as XLPicture; + picture.RelId = imgId; - Xdr.ShapeProperties spPr = anchor.Descendants().First(); - picture.Placement = XLPicturePlacement.FreeFloating; + var spPr = anchor.Descendants().First(); + picture.Placement = XLPicturePlacement.FreeFloating; - if (spPr?.Transform2D?.Extents?.Cx.HasValue ?? false) - picture.Width = ConvertFromEnglishMetricUnits(spPr.Transform2D.Extents.Cx, GraphicsUtils.Graphics.DpiX); + if (spPr?.Transform2D?.Extents?.Cx.HasValue ?? false) + { + picture.Width = ConvertFromEnglishMetricUnits(spPr.Transform2D.Extents.Cx, 72); + } + + if (spPr?.Transform2D?.Extents?.Cy.HasValue ?? false) + { + picture.Height = ConvertFromEnglishMetricUnits(spPr.Transform2D.Extents.Cy, 72); + } - if (spPr?.Transform2D?.Extents?.Cy.HasValue ?? false) - picture.Height = ConvertFromEnglishMetricUnits(spPr.Transform2D.Extents.Cy, GraphicsUtils.Graphics.DpiY); + if (anchor is Xdr.AbsoluteAnchor) + { + var absoluteAnchor = anchor as Xdr.AbsoluteAnchor; + picture.MoveTo( + ConvertFromEnglishMetricUnits(absoluteAnchor.Position.X.Value, 72), + ConvertFromEnglishMetricUnits(absoluteAnchor.Position.Y.Value, 72) + ); + } + else if (anchor is Xdr.OneCellAnchor) + { + var oneCellAnchor = anchor as Xdr.OneCellAnchor; + var from = LoadMarker(ws, oneCellAnchor.FromMarker); + picture.MoveTo(from.Cell, from.Offset); + } + else if (anchor is Xdr.TwoCellAnchor) + { + var twoCellAnchor = anchor as Xdr.TwoCellAnchor; + var from = LoadMarker(ws, twoCellAnchor.FromMarker); + var to = LoadMarker(ws, twoCellAnchor.ToMarker); - if (anchor is Xdr.AbsoluteAnchor) - { - var absoluteAnchor = anchor as Xdr.AbsoluteAnchor; - picture.MoveTo( - ConvertFromEnglishMetricUnits(absoluteAnchor.Position.X.Value, GraphicsUtils.Graphics.DpiX), - ConvertFromEnglishMetricUnits(absoluteAnchor.Position.Y.Value, GraphicsUtils.Graphics.DpiY) - ); - } - else if (anchor is Xdr.OneCellAnchor) + if (twoCellAnchor.EditAs == null || !twoCellAnchor.EditAs.HasValue || twoCellAnchor.EditAs.Value == Xdr.EditAsValues.TwoCell) { - var oneCellAnchor = anchor as Xdr.OneCellAnchor; - var from = LoadMarker(ws, oneCellAnchor.FromMarker); - picture.MoveTo(from.Cell, from.Offset); + picture.MoveTo(from.Cell, from.Offset, to.Cell, to.Offset); } - else if (anchor is Xdr.TwoCellAnchor) + else if (twoCellAnchor.EditAs.Value == Xdr.EditAsValues.Absolute) { - var twoCellAnchor = anchor as Xdr.TwoCellAnchor; - var from = LoadMarker(ws, twoCellAnchor.FromMarker); - var to = LoadMarker(ws, twoCellAnchor.ToMarker); - - if (twoCellAnchor.EditAs == null || !twoCellAnchor.EditAs.HasValue || twoCellAnchor.EditAs.Value == Xdr.EditAsValues.TwoCell) - { - picture.MoveTo(from.Cell, from.Offset, to.Cell, to.Offset); - } - else if (twoCellAnchor.EditAs.Value == Xdr.EditAsValues.Absolute) - { - var shapeProperties = twoCellAnchor.Descendants().FirstOrDefault(); - if (shapeProperties != null) - { - picture.MoveTo( - ConvertFromEnglishMetricUnits(spPr.Transform2D.Offset.X, GraphicsUtils.Graphics.DpiX), - ConvertFromEnglishMetricUnits(spPr.Transform2D.Offset.Y, GraphicsUtils.Graphics.DpiY) - ); - } - } - else if (twoCellAnchor.EditAs.Value == Xdr.EditAsValues.OneCell) + var shapeProperties = twoCellAnchor.Descendants().FirstOrDefault(); + if (shapeProperties != null) { - picture.MoveTo(from.Cell, from.Offset); + picture.MoveTo( + ConvertFromEnglishMetricUnits(spPr.Transform2D.Offset.X, 72), + ConvertFromEnglishMetricUnits(spPr.Transform2D.Offset.Y, 72) + ); } } + else if (twoCellAnchor.EditAs.Value == Xdr.EditAsValues.OneCell) + { + picture.MoveTo(from.Cell, from.Offset); + } } } } } - private static Int32 ConvertFromEnglishMetricUnits(long emu, float resolution) + private static int ConvertFromEnglishMetricUnits(long emu, float resolution) { return Convert.ToInt32(emu * resolution / 914400); } @@ -1193,9 +1605,9 @@ private static XLMarker LoadMarker(IXLWorksheet ws, Xdr.MarkerType marker) var column = Math.Min(XLHelper.MaxColumnNumber, Math.Max(1, Convert.ToInt32(marker.ColumnId.InnerText) + 1)); return new XLMarker( ws.Cell(row, column), - new Point( - ConvertFromEnglishMetricUnits(Convert.ToInt32(marker.ColumnOffset.InnerText), GraphicsUtils.Graphics.DpiX), - ConvertFromEnglishMetricUnits(Convert.ToInt32(marker.RowOffset.InnerText), GraphicsUtils.Graphics.DpiY) + new SKPoint( + ConvertFromEnglishMetricUnits(Convert.ToInt32(marker.ColumnOffset.InnerText), 72), + ConvertFromEnglishMetricUnits(Convert.ToInt32(marker.RowOffset.InnerText), 72) ) ); } @@ -1207,28 +1619,32 @@ private static IList GetCommentShapes(WorksheetPart worksheetPart) // Cannot get this to return Vml.Shape elements foreach (var vmlPart in worksheetPart.VmlDrawingParts) { - using (var stream = vmlPart.GetStream(FileMode.Open)) + using var stream = vmlPart.GetStream(FileMode.Open); + var xdoc = XDocumentExtensions.Load(stream); + if (xdoc == null) { - var xdoc = XDocumentExtensions.Load(stream); - if (xdoc == null) - continue; + continue; + } - var root = xdoc.Root.Element("xml") ?? xdoc.Root; + var root = xdoc.Root.Element("xml") ?? xdoc.Root; - if (root == null) - continue; + if (root == null) + { + continue; + } - var shapes = root - .Elements(XName.Get("shape", "urn:schemas-microsoft-com:vml")) - .Where(e => new[] - { + var shapes = root + .Elements(XName.Get("shape", "urn:schemas-microsoft-com:vml")) + .Where(e => new[] + { "#" + XLConstants.Comment.ShapeTypeId , "#" + XLConstants.Comment.AlternateShapeTypeId - }.Contains(e.Attribute("type")?.Value)) - .ToList(); + }.Contains(e.Attribute("type")?.Value)) + .ToList(); - if (shapes != null) - return shapes; + if (shapes != null) + { + return shapes; } } @@ -1237,20 +1653,20 @@ private static IList GetCommentShapes(WorksheetPart worksheetPart) #endregion Comment Helpers - private String GetTableColumnName(string name) + private string GetTableColumnName(string name) { - return name.Replace("_x000a_", Environment.NewLine).Replace("_x005f_x000a_", "_x000a_"); + return name.Replace("_x000a_", XLConstants.NewLine).Replace("_x005f_x000a_", "_x000a_"); } // This may be part of XLHelper or XLColor // Leaving it here for now. Can't decide what to call it and where to put it. - private XLColor ExtractColor(String color) + private XLColor ExtractColor(string color) { if (color.IndexOf("[") >= 0) { - int start = color.IndexOf("[") + 1; - int end = color.IndexOf("]", start); - return XLColor.FromIndex(Int32.Parse(color.Substring(start, end - start))); + var start = color.IndexOf("[") + 1; + var end = color.IndexOf("]", start); + return XLColor.FromIndex(int.Parse(color.Substring(start, end - start))); } else { @@ -1261,14 +1677,22 @@ private XLColor ExtractColor(String color) private void LoadColorsAndLines(IXLDrawing drawing, XElement shape) { var strokeColor = shape.Attribute("strokecolor"); - if (strokeColor != null) drawing.Style.ColorsAndLines.LineColor = ExtractColor(strokeColor.Value); + if (strokeColor != null) + { + drawing.Style.ColorsAndLines.LineColor = ExtractColor(strokeColor.Value); + } var strokeWeight = shape.Attribute("strokeweight"); if (strokeWeight != null && TryGetPtValue(strokeWeight.Value, out var lineWeight)) + { drawing.Style.ColorsAndLines.LineWeight = lineWeight; + } var fillColor = shape.Attribute("fillcolor"); - if (fillColor != null && !fillColor.Value.ToLower().Contains("infobackground")) drawing.Style.ColorsAndLines.FillColor = ExtractColor(fillColor.Value); + if (fillColor != null && !fillColor.Value.ToLower().Contains("infobackground")) + { + drawing.Style.ColorsAndLines.FillColor = ExtractColor(fillColor.Value); + } var fill = shape.Elements().FirstOrDefault(e => e.Name.LocalName == "fill"); if (fill != null) @@ -1276,12 +1700,16 @@ private void LoadColorsAndLines(IXLDrawing drawing, XElement shape) var opacity = fill.Attribute("opacity"); if (opacity != null) { - String opacityVal = opacity.Value; + var opacityVal = opacity.Value; if (opacityVal.EndsWith("f")) + { drawing.Style.ColorsAndLines.FillTransparency = - Double.Parse(opacityVal.Substring(0, opacityVal.Length - 1), CultureInfo.InvariantCulture) / 65536.0; + double.Parse(opacityVal.Substring(0, opacityVal.Length - 1), CultureInfo.InvariantCulture) / 65536.0; + } else - drawing.Style.ColorsAndLines.FillTransparency = Double.Parse(opacityVal, CultureInfo.InvariantCulture); + { + drawing.Style.ColorsAndLines.FillTransparency = double.Parse(opacityVal, CultureInfo.InvariantCulture); + } } } @@ -1291,25 +1719,33 @@ private void LoadColorsAndLines(IXLDrawing drawing, XElement shape) var opacity = stroke.Attribute("opacity"); if (opacity != null) { - String opacityVal = opacity.Value; + var opacityVal = opacity.Value; if (opacityVal.EndsWith("f")) + { drawing.Style.ColorsAndLines.LineTransparency = - Double.Parse(opacityVal.Substring(0, opacityVal.Length - 1), CultureInfo.InvariantCulture) / 65536.0; + double.Parse(opacityVal.Substring(0, opacityVal.Length - 1), CultureInfo.InvariantCulture) / 65536.0; + } else - drawing.Style.ColorsAndLines.LineTransparency = Double.Parse(opacityVal, CultureInfo.InvariantCulture); + { + drawing.Style.ColorsAndLines.LineTransparency = double.Parse(opacityVal, CultureInfo.InvariantCulture); + } } var dashStyle = stroke.Attribute("dashstyle"); if (dashStyle != null) { - String dashStyleVal = dashStyle.Value.ToLower(); + var dashStyleVal = dashStyle.Value.ToLower(); if (dashStyleVal == "1 1" || dashStyleVal == "shortdot") { var endCap = stroke.Attribute("endcap"); if (endCap != null && endCap.Value == "round") + { drawing.Style.ColorsAndLines.LineDash = XLDashStyle.RoundDot; + } else + { drawing.Style.ColorsAndLines.LineDash = XLDashStyle.SquareDot; + } } else { @@ -1327,7 +1763,7 @@ private void LoadColorsAndLines(IXLDrawing drawing, XElement shape) var lineStyle = stroke.Attribute("linestyle"); if (lineStyle != null) { - String lineStyleVal = lineStyle.Value.ToLower(); + var lineStyleVal = lineStyle.Value.ToLower(); switch (lineStyleVal) { case "single": drawing.Style.ColorsAndLines.LineStyle = XLLineStyle.Single; break; @@ -1343,10 +1779,16 @@ private void LoadColorsAndLines(IXLDrawing drawing, XElement shape) private void LoadTextBox(IXLDrawing xlDrawing, XElement textBox) { var attStyle = textBox.Attribute("style"); - if (attStyle != null) LoadTextBoxStyle(xlDrawing, attStyle); + if (attStyle != null) + { + LoadTextBoxStyle(xlDrawing, attStyle); + } var attInset = textBox.Attribute("inset"); - if (attInset != null) LoadTextBoxInset(xlDrawing, attInset); + if (attInset != null) + { + LoadTextBoxInset(xlDrawing, attInset); + } } private void LoadTextBoxInset(IXLDrawing xlDrawing, XAttribute attInset) @@ -1360,79 +1802,102 @@ private void LoadTextBoxInset(IXLDrawing xlDrawing, XAttribute attInset) private double GetInsetValue(string value) { - String v = value.Trim(); + var v = value.Trim(); if (v.EndsWith("pt")) - return Double.Parse(v.Substring(0, v.Length - 2), CultureInfo.InvariantCulture) / 72.0; + { + return double.Parse(v.Substring(0, v.Length - 2), CultureInfo.InvariantCulture) / 72.0; + } else - return Double.Parse(v.Substring(0, v.Length - 2), CultureInfo.InvariantCulture); + { + return double.Parse(v.Substring(0, v.Length - 2), CultureInfo.InvariantCulture); + } } private static void LoadTextBoxStyle(IXLDrawing xlDrawing, XAttribute attStyle) { var style = attStyle.Value; var attributes = style.Split(';'); - foreach (String pair in attributes) + foreach (var pair in attributes) { var split = pair.Split(':'); - if (split.Length != 2) continue; + if (split.Length != 2) + { + continue; + } var attribute = split[0].Trim().ToLower(); var value = split[1].Trim(); - Boolean isVertical = false; + var isVertical = false; switch (attribute) { case "mso-fit-shape-to-text": xlDrawing.Style.Size.SetAutomaticSize(value.Equals("t")); break; case "mso-layout-flow-alt": - if (value.Equals("bottom-to-top")) xlDrawing.Style.Alignment.SetOrientation(XLDrawingTextOrientation.BottomToTop); - else if (value.Equals("top-to-bottom")) xlDrawing.Style.Alignment.SetOrientation(XLDrawingTextOrientation.Vertical); + if (value.Equals("bottom-to-top")) + { + xlDrawing.Style.Alignment.SetOrientation(XLDrawingTextOrientation.BottomToTop); + } + else if (value.Equals("top-to-bottom")) + { + xlDrawing.Style.Alignment.SetOrientation(XLDrawingTextOrientation.Vertical); + } + break; case "layout-flow": isVertical = value.Equals("vertical"); break; - case "mso-direction-alt": if (value == "auto") xlDrawing.Style.Alignment.Direction = XLDrawingTextDirection.Context; break; - case "direction": if (value == "RTL") xlDrawing.Style.Alignment.Direction = XLDrawingTextDirection.RightToLeft; break; + case "mso-direction-alt": if (value == "auto") { xlDrawing.Style.Alignment.Direction = XLDrawingTextDirection.Context; } break; + case "direction": if (value == "RTL") { xlDrawing.Style.Alignment.Direction = XLDrawingTextDirection.RightToLeft; } break; } if (isVertical && xlDrawing.Style.Alignment.Orientation == XLDrawingTextOrientation.LeftToRight) + { xlDrawing.Style.Alignment.Orientation = XLDrawingTextOrientation.TopToBottom; + } } } private void LoadClientData(IXLDrawing drawing, XElement clientData) { var anchor = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "Anchor"); - if (anchor != null) LoadClientDataAnchor(drawing, anchor); + if (anchor != null) + { + LoadClientDataAnchor(drawing, anchor); + } - LoadDrawingPositioning(drawing, clientData); - LoadDrawingProtection(drawing, clientData); + LoadDrawingPositioning(drawing, clientData); + LoadDrawingProtection(drawing, clientData); var visible = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "Visible"); drawing.Visible = visible != null && (string.IsNullOrEmpty(visible.Value) || visible.Value.StartsWith("t", StringComparison.OrdinalIgnoreCase)); - LoadDrawingHAlignment(drawing, clientData); - LoadDrawingVAlignment(drawing, clientData); + LoadDrawingHAlignment(drawing, clientData); + LoadDrawingVAlignment(drawing, clientData); } private void LoadDrawingHAlignment(IXLDrawing drawing, XElement clientData) { var textHAlign = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "TextHAlign"); if (textHAlign != null) + { drawing.Style.Alignment.Horizontal = (XLDrawingHorizontalAlignment)Enum.Parse(typeof(XLDrawingHorizontalAlignment), textHAlign.Value.ToProper()); + } } private void LoadDrawingVAlignment(IXLDrawing drawing, XElement clientData) { var textVAlign = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "TextVAlign"); if (textVAlign != null) + { drawing.Style.Alignment.Vertical = (XLDrawingVerticalAlignment)Enum.Parse(typeof(XLDrawingVerticalAlignment), textVAlign.Value.ToProper()); + } } private void LoadDrawingProtection(IXLDrawing drawing, XElement clientData) { var lockedElement = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "Locked"); var lockTextElement = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "LockText"); - Boolean locked = lockedElement != null && lockedElement.Value.ToLower() == "true"; - Boolean lockText = lockTextElement != null && lockTextElement.Value.ToLower() == "true"; + var locked = lockedElement != null && lockedElement.Value.ToLower() == "true"; + var lockText = lockTextElement != null && lockTextElement.Value.ToLower() == "true"; drawing.Style.Protection.Locked = locked; drawing.Style.Protection.LockText = lockText; } @@ -1441,34 +1906,45 @@ private static void LoadDrawingPositioning(IXLDrawing drawing, XElement cl { var moveWithCellsElement = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "MoveWithCells"); var sizeWithCellsElement = clientData.Elements().FirstOrDefault(e => e.Name.LocalName == "SizeWithCells"); - Boolean moveWithCells = !(moveWithCellsElement != null && moveWithCellsElement.Value.ToLower() == "true"); - Boolean sizeWithCells = !(sizeWithCellsElement != null && sizeWithCellsElement.Value.ToLower() == "true"); + var moveWithCells = !(moveWithCellsElement != null && moveWithCellsElement.Value.ToLower() == "true"); + var sizeWithCells = !(sizeWithCellsElement != null && sizeWithCellsElement.Value.ToLower() == "true"); if (moveWithCells && !sizeWithCells) + { drawing.Style.Properties.Positioning = XLDrawingAnchor.MoveWithCells; + } else if (moveWithCells && sizeWithCells) + { drawing.Style.Properties.Positioning = XLDrawingAnchor.MoveAndSizeWithCells; + } else + { drawing.Style.Properties.Positioning = XLDrawingAnchor.Absolute; + } } private static void LoadClientDataAnchor(IXLDrawing drawing, XElement anchor) { var location = anchor.Value.Split(','); drawing.Position.Column = int.Parse(location[0]) + 1; - drawing.Position.ColumnOffset = Double.Parse(location[1], CultureInfo.InvariantCulture) / 7.5; + drawing.Position.ColumnOffset = double.Parse(location[1], CultureInfo.InvariantCulture) / 7.5; drawing.Position.Row = int.Parse(location[2]) + 1; - drawing.Position.RowOffset = Double.Parse(location[3], CultureInfo.InvariantCulture); + drawing.Position.RowOffset = double.Parse(location[3], CultureInfo.InvariantCulture); } private void LoadShapeProperties(IXLDrawing xlDrawing, XElement shape) { if (shape.Attribute("style") == null) + { return; + } foreach (var attributePair in shape.Attribute("style").Value.Split(';')) { var split = attributePair.Split(':'); - if (split.Length != 2) continue; + if (split.Length != 2) + { + continue; + } var attribute = split[0].Trim().ToLower(); var value = split[1].Trim(); @@ -1491,7 +1967,7 @@ private void LoadShapeProperties(IXLDrawing xlDrawing, XElement shape) break; case "z-index": - if (Int32.TryParse(value, out var zOrder)) + if (int.TryParse(value, out var zOrder)) { xlDrawing.ZOrder = zOrder; } @@ -1512,11 +1988,13 @@ private bool TryGetPtValue(string value, out double result) var knownUnit = knownUnits.FirstOrDefault(ku => value.Contains(ku.Key)); if (knownUnit.Key == null) - return Double.TryParse(value, out result); + { + return double.TryParse(value, out result); + } - value = value.Replace(knownUnit.Key, String.Empty); + value = value.Replace(knownUnit.Key, string.Empty); - if (Double.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out result)) + if (double.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out result)) { result *= knownUnit.Value; return true; @@ -1528,21 +2006,30 @@ private bool TryGetPtValue(string value, out double result) private void LoadDefinedNames(Workbook workbook) { - if (workbook.DefinedNames == null) return; + if (workbook.DefinedNames == null) + { + return; + } foreach (var definedName in workbook.DefinedNames.OfType()) { var name = definedName.Name; var visible = true; - if (definedName.Hidden != null) visible = !BooleanValue.ToBoolean(definedName.Hidden); + if (definedName.Hidden != null) + { + visible = !BooleanValue.ToBoolean(definedName.Hidden); + } var localSheetId = -1; - if (definedName.LocalSheetId?.HasValue ?? false) localSheetId = Convert.ToInt32(definedName.LocalSheetId.Value); + if (definedName.LocalSheetId?.HasValue ?? false) + { + localSheetId = Convert.ToInt32(definedName.LocalSheetId.Value); + } if (name == "_xlnm.Print_Area") { var fixedNames = validateDefinedNames(definedName.Text.Split(',')); - foreach (string area in fixedNames) + foreach (var area in fixedNames) { if (area.Contains("[")) { @@ -1554,9 +2041,11 @@ private void LoadDefinedNames(Workbook workbook) } else { - ParseReference(area, out String sheetName, out String sheetArea); + ParseReference(area, out var sheetName, out var sheetArea); if (!(sheetArea.Equals("#REF") || sheetArea.EndsWith("#REF!") || sheetArea.Length == 0 || sheetName.Length == 0)) + { WorksheetsInternal.Worksheet(sheetName).PageSetup.PrintAreas.Add(sheetArea); + } } } } @@ -1566,36 +2055,42 @@ private void LoadDefinedNames(Workbook workbook) } else { - string text = definedName.Text; + var text = definedName.Text; var comment = definedName.Comment; if (localSheetId == -1) { if (NamedRanges.All(nr => nr.Name != name)) + { (NamedRanges as XLNamedRanges).Add(name, text, comment, validateName: false, validateRangeAddress: false).Visible = visible; + } } else { if (Worksheet(localSheetId + 1).NamedRanges.All(nr => nr.Name != name)) + { (Worksheet(localSheetId + 1).NamedRanges as XLNamedRanges).Add(name, text, comment, validateName: false, validateRangeAddress: false).Visible = visible; + } } } } } - private static Regex definedNameRegex = new Regex(@"\A'.*'!.*\z", RegexOptions.Compiled); + private static readonly Regex definedNameRegex = new Regex(@"\A'.*'!.*\z", RegexOptions.Compiled); - private IEnumerable validateDefinedNames(IEnumerable definedNames) + private IEnumerable validateDefinedNames(IEnumerable definedNames) { var sb = new StringBuilder(); - foreach (string testName in definedNames) + foreach (var testName in definedNames) { if (sb.Length > 0) + { sb.Append(','); + } sb.Append(testName); - Match matchedValidPattern = definedNameRegex.Match(sb.ToString()); + var matchedValidPattern = definedNameRegex.Match(sb.ToString()); if (matchedValidPattern.Success) { yield return sb.ToString(); @@ -1604,7 +2099,9 @@ private IEnumerable validateDefinedNames(IEnumerable definedName } if (sb.Length > 0) + { yield return sb.ToString(); + } } private void LoadPrintTitles(DefinedName definedName) @@ -1612,21 +2109,32 @@ private void LoadPrintTitles(DefinedName definedName) var areas = validateDefinedNames(definedName.Text.Split(',')); foreach (var item in areas) { - if (this.Range(item) != null) + if (Range(item) != null) + { SetColumnsOrRowsToRepeat(item); + } } } private void SetColumnsOrRowsToRepeat(string area) { - ParseReference(area, out String sheetName, out String sheetArea); + ParseReference(area, out var sheetName, out var sheetArea); sheetArea = sheetArea.Replace("$", ""); - if (sheetArea.Equals("#REF")) return; + if (sheetArea.Equals("#REF")) + { + return; + } + if (IsColReference(sheetArea)) + { WorksheetsInternal.Worksheet(sheetName).PageSetup.SetColumnsToRepeatAtLeft(sheetArea); + } + if (IsRowReference(sheetArea)) + { WorksheetsInternal.Worksheet(sheetName).PageSetup.SetRowsToRepeatAtTop(sheetArea); + } } // either $A:$X => true or $1:$99 => false @@ -1643,7 +2151,7 @@ private static bool IsRowReference(string sheetArea) private static void ParseReference(string item, out string sheetName, out string sheetArea) { var sections = item.Trim().Split('!'); - if (sections.Count() == 1) + if (sections.Length == 1) { sheetName = string.Empty; sheetArea = item; @@ -1655,13 +2163,13 @@ private static void ParseReference(string item, out string sheetName, out string } } - private Int32 lastColumnNumber; + private int lastColumnNumber; private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, NumberingFormats numberingFormats, Fills fills, Borders borders, Fonts fonts, Dictionary sharedFormulasR1C1, - XLWorksheet ws, Dictionary styleList, Cell cell, Int32 rowIndex) + XLWorksheet ws, Dictionary styleList, Cell cell, int rowIndex) { - Int32 styleIndex = cell.StyleIndex != null ? Int32.Parse(cell.StyleIndex.InnerText) : 0; + var styleIndex = cell.StyleIndex != null ? int.Parse(cell.StyleIndex.InnerText) : 0; XLAddress cellAddress; if (cell.CellReference == null) @@ -1676,7 +2184,7 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering var xlCell = ws.Cell(in cellAddress); - if (styleList.TryGetValue(styleIndex, out IXLStyle style)) + if (styleList.TryGetValue(styleIndex, out var style)) { xlCell.InnerStyle = style; } @@ -1687,11 +2195,15 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering if (cell.CellFormula?.SharedIndex != null && cell.CellFormula?.Reference != null) { - String formula; + string formula; if (cell.CellFormula.FormulaType != null && cell.CellFormula.FormulaType == CellFormulaValues.Array) + { formula = "{" + cell.CellFormula.Text + "}"; + } else + { formula = cell.CellFormula.Text; + } // Parent cell of shared formulas // Child cells will use this shared index to set its R1C1 style formula @@ -1727,14 +2239,20 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering else if (cell.CellFormula != null) { if (cell.CellFormula.SharedIndex != null) + { xlCell.FormulaR1C1 = sharedFormulasR1C1[cell.CellFormula.SharedIndex.Value]; - else if (!String.IsNullOrWhiteSpace(cell.CellFormula.Text)) + } + else if (!string.IsNullOrWhiteSpace(cell.CellFormula.Text)) { - String formula; + string formula; if (cell.CellFormula.FormulaType != null && cell.CellFormula.FormulaType == CellFormulaValues.Array) + { formula = "{" + cell.CellFormula.Text + "}"; + } else + { formula = cell.CellFormula.Text; + } xlCell.FormulaA1 = formula; } @@ -1744,10 +2262,14 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering foreach (var childCell in ws.Range(cell.CellFormula.Reference.Value).Cells(c => c.FormulaReference == null || !c.HasFormula)) { if (childCell.FormulaReference == null) + { childCell.FormulaReference = ws.Range(cell.CellFormula.Reference.Value).RangeAddress; + } if (!childCell.HasFormula) + { childCell.FormulaA1 = xlCell.FormulaA1; + } } } @@ -1785,19 +2307,25 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering if (cell.InlineString != null) { if (cell.InlineString.Text != null) + { xlCell.SetInternalCellValueString(cell.InlineString.Text.Text.FixNewLines()); + } else + { ParseCellValue(cell.InlineString, xlCell); + } } else - xlCell.SetInternalCellValueString(String.Empty); + { + xlCell.SetInternalCellValueString(string.Empty); + } } else if (cell.DataType == CellValues.SharedString) { xlCell.SetDataTypeFast(XLDataType.Text); if (cell.CellValue != null - && Int32.TryParse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture, out Int32 sharedStringId) + && int.TryParse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture, out var sharedStringId) && sharedStringId >= 0 && sharedStringId < sharedStrings.Length) { xlCell.SharedStringId = sharedStringId; @@ -1805,39 +2333,55 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering ParseCellValue(sharedString, xlCell); } else - xlCell.SetInternalCellValueString(String.Empty); + { + xlCell.SetInternalCellValueString(string.Empty); + } } else if (cell.DataType == CellValues.String) { xlCell.SetDataTypeFast(XLDataType.Text); - if (!String.IsNullOrEmpty(cell.CellValue?.Text)) + if (!string.IsNullOrEmpty(cell.CellValue?.Text)) + { xlCell.SetInternalCellValueString(cell.CellValue.Text); + } else - xlCell.SetInternalCellValueString(String.Empty); + { + xlCell.SetInternalCellValueString(string.Empty); + } } else if (cell.DataType == CellValues.Date) { xlCell.SetDataTypeFast(XLDataType.DateTime); - if (cell.CellValue != null && !String.IsNullOrWhiteSpace(cell.CellValue.Text)) - xlCell.SetInternalCellValueString(Double.Parse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture).ToInvariantString()); + if (cell.CellValue != null && !string.IsNullOrWhiteSpace(cell.CellValue.Text)) + { + xlCell.SetDateValue(cell.CellValue.Text); + } } else if (cell.DataType == CellValues.Boolean) { xlCell.SetDataTypeFast(XLDataType.Boolean); if (cell.CellValue != null) + { xlCell.SetInternalCellValueString(cell.CellValue.Text); + } } else if (cell.DataType == CellValues.Number) { if (s == null) + { xlCell.SetDataTypeFast(XLDataType.Number); + } else + { xlCell.DataType = GetDataTypeFromCell(xlCell.StyleValue.NumberFormat); + } - if (cell.CellValue != null && !String.IsNullOrWhiteSpace(cell.CellValue.Text)) - xlCell.SetInternalCellValueString(Double.Parse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture).ToInvariantString()); + if (cell.CellValue != null && !string.IsNullOrWhiteSpace(cell.CellValue.Text)) + { + xlCell.SetInternalCellValueString(double.Parse(cell.CellValue.Text, XLHelper.NumberStyle, XLHelper.ParseCulture).ToInvariantString()); + } } } else if (cell.CellValue != null) @@ -1850,10 +2394,12 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering { xlCell.DataType = GetDataTypeFromCell(xlCell.StyleValue.NumberFormat); - if (!String.IsNullOrWhiteSpace(cell.CellValue.Text)) - xlCell.SetInternalCellValueString(Double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToInvariantString()); + if (!string.IsNullOrWhiteSpace(cell.CellValue.Text)) + { + xlCell.SetInternalCellValueString(double.Parse(cell.CellValue.Text, CultureInfo.InvariantCulture).ToInvariantString()); + } - var numberFormatId = ((CellFormat)(s.CellFormats).ElementAt(styleIndex)).NumberFormatId; + var numberFormatId = ((CellFormat)s.CellFormats.ElementAt(styleIndex)).NumberFormatId; if (numberFormatId?.HasValue ?? false) { @@ -1864,9 +2410,13 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering .FirstOrDefault(); if (format == null) - xlCell.InnerStyle.NumberFormat.NumberFormatId = Int32.Parse(numberFormatId); + { + xlCell.InnerStyle.NumberFormat.NumberFormatId = int.Parse(numberFormatId); + } else + { xlCell.InnerStyle.NumberFormat.Format = format; + } } } } @@ -1874,9 +2424,11 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering if (xlCell.HasFormula) { if (cell.CellValue != null) + { xlCell.SetInternalCellValueString(cell.CellValue.Text); + } - xlCell.NeedsRecalculation = (xlCell.CachedValue == null); + xlCell.NeedsRecalculation = xlCell.CachedValue == null; } if (Use1904DateSystem && xlCell.DataType == XLDataType.DateTime) @@ -1887,7 +2439,9 @@ private void LoadCells(SharedStringItem[] sharedStrings, Stylesheet s, Numbering } if (!styleList.ContainsKey(styleIndex)) + { styleList.Add(styleIndex, xlCell.Style); + } } /// @@ -1901,25 +2455,31 @@ private void ParseCellValue(RstType element, XLCell xlCell) var runs = element.Elements(); var phoneticRuns = element.Elements(); var phoneticProperties = element.Elements(); - Boolean hasRuns = false; - foreach (Run run in runs) + var hasRuns = false; + foreach (var run in runs) { var runProperties = run.RunProperties; - String text = run.Text.InnerText.FixNewLines(); + var text = run.Text.InnerText.FixNewLines(); if (runProperties == null) + { xlCell.GetRichText().AddText(text, xlCell.Style.Font); + } else { var rt = xlCell.GetRichText().AddText(text); LoadFont(runProperties, rt); } if (!hasRuns) + { hasRuns = true; + } } if (!hasRuns) - xlCell.SetInternalCellValueString(XmlEncoder.DecodeString(element.Text.InnerText)); + { + xlCell.SetInternalCellValueString(XmlEncoder.DecodeString(element.Text?.InnerText)); + } #region Load PhoneticProperties @@ -1927,9 +2487,14 @@ private void ParseCellValue(RstType element, XLCell xlCell) if (pp != null) { if (pp.Alignment != null) + { xlCell.GetRichText().Phonetics.Alignment = pp.Alignment.Value.ToClosedXml(); + } + if (pp.Type != null) + { xlCell.GetRichText().Phonetics.Type = pp.Type.Value.ToClosedXml(); + } LoadFont(pp, xlCell.GetRichText().Phonetics); } @@ -1938,10 +2503,10 @@ private void ParseCellValue(RstType element, XLCell xlCell) #region Load Phonetic Runs - foreach (PhoneticRun pr in phoneticRuns) + foreach (var pr in phoneticRuns) { - xlCell.GetRichText().Phonetics.Add(pr.Text.InnerText.FixNewLines(), (Int32)pr.BaseTextStartIndex.Value, - (Int32)pr.EndingBaseIndex.Value); + xlCell.GetRichText().Phonetics.Add(pr.Text.InnerText.FixNewLines(), (int)pr.BaseTextStartIndex.Value, + (int)pr.EndingBaseIndex.Value); } #endregion Load Phonetic Runs @@ -1949,24 +2514,39 @@ private void ParseCellValue(RstType element, XLCell xlCell) private void LoadNumberFormat(NumberingFormat nfSource, IXLNumberFormat nf) { - if (nfSource == null) return; + if (nfSource == null) + { + return; + } if (nfSource.NumberFormatId != null && nfSource.NumberFormatId.Value < XLConstants.NumberOfBuiltInStyles) - nf.NumberFormatId = (Int32)nfSource.NumberFormatId.Value; + { + nf.NumberFormatId = (int)nfSource.NumberFormatId.Value; + } else if (nfSource.FormatCode != null) + { nf.Format = nfSource.FormatCode.Value; + } } private void LoadBorder(Border borderSource, IXLBorder border) { - if (borderSource == null) return; + if (borderSource == null) + { + return; + } LoadBorderValues(borderSource.DiagonalBorder, border.SetDiagonalBorder, border.SetDiagonalBorderColor); if (borderSource.DiagonalUp != null) + { border.DiagonalUp = borderSource.DiagonalUp.Value; + } + if (borderSource.DiagonalDown != null) + { border.DiagonalDown = borderSource.DiagonalDown.Value; + } LoadBorderValues(borderSource.LeftBorder, border.SetLeftBorder, border.SetLeftBorderColor); LoadBorderValues(borderSource.RightBorder, border.SetRightBorder, border.SetRightBorderColor); @@ -1979,23 +2559,35 @@ private void LoadBorderValues(BorderPropertiesType source, Func().FirstOrDefault()); - var fontColor = fontSource.Elements().FirstOrDefault(); + var fontColor = fontSource.Elements().FirstOrDefault(); if (fontColor != null) + { fontBase.FontColor = fontColor.ToClosedXMLColor(_colorList); + } var fontFamilyNumbering = - fontSource.Elements().FirstOrDefault(); + fontSource.Elements().FirstOrDefault(); if (fontFamilyNumbering != null && fontFamilyNumbering.Val != null) + { fontBase.FontFamilyNumbering = - (XLFontFamilyNumberingValues)Int32.Parse(fontFamilyNumbering.Val.ToString()); + (XLFontFamilyNumberingValues)int.Parse(fontFamilyNumbering.Val.ToString()); + } + var runFont = fontSource.Elements().FirstOrDefault(); - if (runFont != null) + if (runFont != null && runFont.Val != null) { - if (runFont.Val != null) - fontBase.FontName = runFont.Val; + fontBase.FontName = runFont.Val; } var fontSize = fontSource.Elements().FirstOrDefault(); - if (fontSize != null) + if (fontSize != null && fontSize.Val != null) { - if ((fontSize).Val != null) - fontBase.FontSize = (fontSize).Val; + fontBase.FontSize = fontSize.Val; } fontBase.Italic = GetBoolean(fontSource.Elements().FirstOrDefault()); @@ -2071,23 +2684,28 @@ private void LoadFont(OpenXmlElement fontSource, IXLFontBase fontBase) var verticalTextAlignment = fontSource.Elements().FirstOrDefault(); - if (verticalTextAlignment == null) return; + if (verticalTextAlignment == null) + { + return; + } fontBase.VerticalAlignment = verticalTextAlignment.Val != null ? verticalTextAlignment.Val.Value.ToClosedXml() : XLFontVerticalTextAlignmentValues.Baseline; } - private Int32 lastRow; + private int lastRow; private void LoadRows(Stylesheet s, NumberingFormats numberingFormats, Fills fills, Borders borders, Fonts fonts, XLWorksheet ws, SharedStringItem[] sharedStrings, - Dictionary sharedFormulasR1C1, Dictionary styleList, + Dictionary sharedFormulasR1C1, Dictionary styleList, Row row) { - Int32 rowIndex = row.RowIndex == null ? ++lastRow : (Int32)row.RowIndex.Value; + var rowIndex = row.RowIndex == null ? ++lastRow : (int)row.RowIndex.Value; var xlRow = ws.Row(rowIndex, false); if (row.Height != null) + { xlRow.Height = row.Height; + } else { xlRow.Loading = true; @@ -2096,17 +2714,23 @@ private void LoadRows(Stylesheet s, NumberingFormats numberingFormats, Fills fil } if (row.Hidden != null && row.Hidden) + { xlRow.Hide(); + } if (row.Collapsed != null && row.Collapsed) + { xlRow.Collapsed = true; + } if (row.OutlineLevel != null && row.OutlineLevel > 0) + { xlRow.OutlineLevel = row.OutlineLevel; + } if (row.CustomFormat != null) { - Int32 styleIndex = row.StyleIndex != null ? Int32.Parse(row.StyleIndex.InnerText) : -1; + var styleIndex = row.StyleIndex != null ? int.Parse(row.StyleIndex.InnerText) : -1; if (styleIndex >= 0) { ApplyStyle(xlRow, styleIndex, s, fills, borders, fonts, numberingFormats); @@ -2118,48 +2742,65 @@ private void LoadRows(Stylesheet s, NumberingFormats numberingFormats, Fills fil } lastColumnNumber = 0; - foreach (Cell cell in row.Elements()) + foreach (var cell in row.Elements()) + { LoadCells(sharedStrings, s, numberingFormats, fills, borders, fonts, sharedFormulasR1C1, ws, styleList, cell, rowIndex); + } } private void LoadColumns(Stylesheet s, NumberingFormats numberingFormats, Fills fills, Borders borders, Fonts fonts, XLWorksheet ws, Columns columns) { - if (columns == null) return; + if (columns == null) + { + return; + } var wsDefaultColumn = columns.Elements().FirstOrDefault(c => c.Max == XLHelper.MaxColumnNumber); if (wsDefaultColumn != null && wsDefaultColumn.Width != null) + { ws.ColumnWidth = wsDefaultColumn.Width - ColumnWidthOffset; + } - Int32 styleIndexDefault = wsDefaultColumn != null && wsDefaultColumn.Style != null - ? Int32.Parse(wsDefaultColumn.Style.InnerText) + var styleIndexDefault = wsDefaultColumn != null && wsDefaultColumn.Style != null + ? int.Parse(wsDefaultColumn.Style.InnerText) : -1; if (styleIndexDefault >= 0) + { ApplyStyle(ws, styleIndexDefault, s, fills, borders, fonts, numberingFormats); + } - foreach (Column col in columns.Elements()) + foreach (var col in columns.Elements()) { //IXLStylized toApply; - if (col.Max == XLHelper.MaxColumnNumber) continue; + if (col.Max == XLHelper.MaxColumnNumber) + { + continue; + } var xlColumns = (XLColumns)ws.Columns(col.Min, col.Max); if (col.Width != null) { - Double width = col.Width - ColumnWidthOffset; - //if (width < 0) width = 0; + var width = col.Width - ColumnWidthOffset; xlColumns.Width = width; } else + { xlColumns.Width = ws.ColumnWidth; + } if (col.Hidden != null && col.Hidden) + { xlColumns.Hide(); + } if (col.Collapsed != null && col.Collapsed) + { xlColumns.CollapseOnly(); + } if (col.OutlineLevel != null) { @@ -2167,7 +2808,7 @@ private void LoadColumns(Stylesheet s, NumberingFormats numberingFormats, Fills xlColumns.ForEach(c => c.OutlineLevel = outlineLevel); } - Int32 styleIndex = col.Style != null ? Int32.Parse(col.Style.InnerText) : -1; + var styleIndex = col.Style != null ? int.Parse(col.Style.InnerText) : -1; if (styleIndex >= 0) { ApplyStyle(xlColumns, styleIndex, s, fills, borders, fonts, numberingFormats); @@ -2183,37 +2824,51 @@ private static XLDataType GetDataTypeFromCell(XLNumberFormatValue numberFormat) { var numberFormatId = numberFormat.NumberFormatId; if (numberFormatId == 46U) + { return XLDataType.TimeSpan; + } else if ((numberFormatId >= 14 && numberFormatId <= 22) || (numberFormatId >= 45 && numberFormatId <= 47)) + { return XLDataType.DateTime; + } else if (numberFormatId == 49) + { return XLDataType.Text; + } else { - if (!String.IsNullOrWhiteSpace(numberFormat.Format)) + if (!string.IsNullOrWhiteSpace(numberFormat.Format)) { var dataType = GetDataTypeFromFormat(numberFormat.Format); return dataType.HasValue ? dataType.Value : XLDataType.Number; } else + { return XLDataType.Number; + } } } - private static XLDataType? GetDataTypeFromFormat(String format) + private static XLDataType? GetDataTypeFromFormat(string format) { - int length = format.Length; - String f = format.ToLower(); - for (Int32 i = 0; i < length; i++) + var length = format.Length; + var f = format.ToLower(); + for (var i = 0; i < length; i++) { - Char c = f[i]; + var c = f[i]; if (c == '"') + { i = f.IndexOf('"', i + 1); + } else if (c == '0' || c == '#' || c == '?') + { return XLDataType.Number; + } else if (c == 'y' || c == 'm' || c == 'd' || c == 'h' || c == 's') + { return XLDataType.DateTime; + } } return null; } @@ -2233,19 +2888,19 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter { foreach (var filterColumn in af.Elements()) { - Int32 column = (int)filterColumn.ColumnId.Value + 1; + var column = (int)filterColumn.ColumnId.Value + 1; if (filterColumn.CustomFilters != null) { var filterList = new List(); autoFilter.Column(column).FilterType = XLFilterType.Custom; autoFilter.Filters.Add(column, filterList); - XLConnector connector = filterColumn.CustomFilters.And != null && filterColumn.CustomFilters.And.Value ? XLConnector.And : XLConnector.Or; + var connector = filterColumn.CustomFilters.And != null && filterColumn.CustomFilters.And.Value ? XLConnector.And : XLConnector.Or; - Boolean isText = false; + var isText = false; foreach (var filter in filterColumn.CustomFilters.OfType()) { - String val = filter.Val.Value; - if (!Double.TryParse(val, out Double dTest)) + var val = filter.Val.Value; + if (!double.TryParse(val, out var dTest)) { isText = true; break; @@ -2277,27 +2932,40 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter xlFilter.Condition = s => XLFilterColumn.BeginsWithFunction(value, s); } else + { xlFilter.Value = filter.Val.Value; + } } else - xlFilter.Value = Double.Parse(filter.Val.Value, CultureInfo.InvariantCulture); + { + xlFilter.Value = double.Parse(filter.Val.Value, CultureInfo.InvariantCulture); + } if (filter.Operator != null) + { xlFilter.Operator = filter.Operator.Value.ToClosedXml(); + } else + { xlFilter.Operator = XLFilterOperator.Equal; + } // Unhandled instances - we should actually improve this if (xlFilter.Condition == null) { - Func condition = null; + Func condition = null; switch (xlFilter.Operator) { case XLFilterOperator.Equal: if (isText) + { condition = o => o.ToString().Equals(xlFilter.Value.ToString(), StringComparison.OrdinalIgnoreCase); + } else + { condition = o => (o as IComparable).CompareTo(xlFilter.Value) == 0; + } + break; case XLFilterOperator.EqualOrGreaterThan: condition = o => (o as IComparable).CompareTo(xlFilter.Value) >= 0; break; @@ -2306,9 +2974,14 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter case XLFilterOperator.LessThan: condition = o => (o as IComparable).CompareTo(xlFilter.Value) < 0; break; case XLFilterOperator.NotEqual: if (isText) + { condition = o => !o.ToString().Equals(xlFilter.Value.ToString(), StringComparison.OrdinalIgnoreCase); + } else + { condition = o => (o as IComparable).CompareTo(xlFilter.Value) != 0; + } + break; } @@ -2321,21 +2994,27 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter else if (filterColumn.Filters != null) { if (filterColumn.Filters.Elements().All(element => element is Filter)) + { autoFilter.Column(column).FilterType = XLFilterType.Regular; + } else if (filterColumn.Filters.Elements().All(element => element is DateGroupItem)) + { autoFilter.Column(column).FilterType = XLFilterType.DateTimeGrouping; + } else - throw new NotSupportedException(String.Format("Mixing regular filters and date group filters in a single autofilter column is not supported. Column {0} of {1}", column, autoFilter.Range.ToString())); + { + throw new NotSupportedException(string.Format("Mixing regular filters and date group filters in a single autofilter column is not supported. Column {0} of {1}", column, autoFilter.Range.ToString())); + } var filterList = new List(); autoFilter.Filters.Add((int)filterColumn.ColumnId.Value + 1, filterList); - Boolean isText = false; + var isText = false; foreach (var filter in filterColumn.Filters.OfType()) { - String val = filter.Val.Value; - if (!Double.TryParse(val, NumberStyles.Any, null, out Double dTest)) + var val = filter.Val.Value; + if (!double.TryParse(val, NumberStyles.Any, null, out var dTest)) { isText = true; break; @@ -2346,7 +3025,7 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter { var xlFilter = new XLFilter { Connector = XLConnector.Or, Operator = XLFilterOperator.Equal }; - Func condition; + Func condition; if (isText) { xlFilter.Value = filter.Val.Value; @@ -2354,7 +3033,7 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter } else { - xlFilter.Value = Double.Parse(filter.Val.Value, NumberStyles.Any); + xlFilter.Value = double.Parse(filter.Val.Value, NumberStyles.Any); condition = o => (o as IComparable).CompareTo(xlFilter.Value) == 0; } @@ -2364,10 +3043,12 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter foreach (var dateGroupItem in filterColumn.Filters.OfType()) { - bool valid = true; + var valid = true; if (!(dateGroupItem.DateTimeGrouping?.HasValue ?? false)) + { continue; + } var xlDateGroupFilter = new XLFilter { @@ -2376,59 +3057,83 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter DateTimeGrouping = dateGroupItem.DateTimeGrouping?.Value.ToClosedXml() ?? XLDateTimeGrouping.Year }; - int year = 1900; - int month = 1; - int day = 1; - int hour = 0; - int minute = 0; - int second = 0; + var year = 1900; + var month = 1; + var day = 1; + var hour = 0; + var minute = 0; + var second = 0; if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Year) { if (dateGroupItem?.Year?.HasValue ?? false) + { year = (int)dateGroupItem.Year?.Value; + } else + { valid &= false; + } } if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Month) { if (dateGroupItem?.Month?.HasValue ?? false) + { month = (int)dateGroupItem.Month?.Value; + } else + { valid &= false; + } } if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Day) { if (dateGroupItem?.Day?.HasValue ?? false) + { day = (int)dateGroupItem.Day?.Value; + } else + { valid &= false; + } } if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Hour) { if (dateGroupItem?.Hour?.HasValue ?? false) + { hour = (int)dateGroupItem.Hour?.Value; + } else + { valid &= false; + } } if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Minute) { if (dateGroupItem?.Minute?.HasValue ?? false) + { minute = (int)dateGroupItem.Minute?.Value; + } else + { valid &= false; + } } if (xlDateGroupFilter.DateTimeGrouping >= XLDateTimeGrouping.Second) { if (dateGroupItem?.Second?.HasValue ?? false) + { second = (int)dateGroupItem.Second?.Value; + } else + { valid &= false; + } } var date = new DateTime(year, month, day, hour, minute, second); @@ -2437,7 +3142,9 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter xlDateGroupFilter.Condition = date2 => XLDateTimeGroupFilteredColumn.IsMatch(date, (DateTime)date2, xlDateGroupFilter.DateTimeGrouping); if (valid) + { filterList.Add(xlDateGroupFilter); + } } } else if (filterColumn.Top10 != null) @@ -2446,14 +3153,22 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter autoFilter.Filters.Add(column, null); xlFilterColumn.FilterType = XLFilterType.TopBottom; if (filterColumn.Top10.Percent != null && filterColumn.Top10.Percent.Value) + { xlFilterColumn.TopBottomType = XLTopBottomType.Percent; + } else + { xlFilterColumn.TopBottomType = XLTopBottomType.Items; + } if (filterColumn.Top10.Top != null && !filterColumn.Top10.Top.Value) + { xlFilterColumn.TopBottomPart = XLTopBottomPart.Bottom; + } else + { xlFilterColumn.TopBottomPart = XLTopBottomPart.Top; + } xlFilterColumn.TopBottomValue = (int)filterColumn.Top10.Val.Value; } @@ -2463,9 +3178,13 @@ private static void LoadAutoFilterColumns(AutoFilter af, XLAutoFilter autoFilter var xlFilterColumn = autoFilter.Column(column); xlFilterColumn.FilterType = XLFilterType.Dynamic; if (filterColumn.DynamicFilter.Type != null) + { xlFilterColumn.DynamicType = filterColumn.DynamicFilter.Type.Value.ToClosedXml(); + } else + { xlFilterColumn.DynamicType = XLFilterDynamicType.AboveAverage; + } xlFilterColumn.DynamicValue = filterColumn.DynamicFilter.Val.Value; } @@ -2480,7 +3199,7 @@ private static void LoadAutoFilterSort(AutoFilter af, XLWorksheet ws, IXLAutoFil var condition = sort.Elements().FirstOrDefault(); if (condition != null) { - Int32 column = ws.Range(condition.Reference.Value).FirstCell().Address.ColumnNumber - autoFilter.Range.FirstCell().Address.ColumnNumber + 1; + var column = ws.Range(condition.Reference.Value).FirstCell().Address.ColumnNumber - autoFilter.Range.FirstCell().Address.ColumnNumber + 1; autoFilter.SortColumn = column; autoFilter.Sorted = true; autoFilter.SortOrder = condition.Descending != null && condition.Descending.Value ? XLSortOrder.Descending : XLSortOrder.Ascending; @@ -2490,12 +3209,15 @@ private static void LoadAutoFilterSort(AutoFilter af, XLWorksheet ws, IXLAutoFil private static void LoadSheetProtection(SheetProtection sp, XLWorksheet ws) { - if (sp == null) return; + if (sp == null) + { + return; + } ws.Protection.IsProtected = OpenXmlHelper.GetBooleanValueAsBool(sp.Sheet, false); var algorithmName = sp.AlgorithmName?.Value ?? string.Empty; - if (String.IsNullOrEmpty(algorithmName)) + if (string.IsNullOrEmpty(algorithmName)) { ws.Protection.PasswordHash = sp.Password?.Value ?? string.Empty; ws.Protection.Base64EncodedSalt = string.Empty; @@ -2528,29 +3250,87 @@ private static void LoadSheetProtection(SheetProtection sp, XLWorksheet ws) private static void LoadDataValidations(DataValidations dataValidations, XLWorksheet ws) { - if (dataValidations == null) return; + if (dataValidations == null) + { + return; + } - foreach (DataValidation dvs in dataValidations.Elements()) + foreach (var dvs in dataValidations.Elements()) { - String txt = dvs.SequenceOfReferences.InnerText; - if (String.IsNullOrWhiteSpace(txt)) continue; + var txt = dvs.SequenceOfReferences.InnerText; + if (string.IsNullOrWhiteSpace(txt)) + { + continue; + } + foreach (var rangeAddress in txt.Split(' ')) { var dvt = new XLDataValidation(ws.Range(rangeAddress)); ws.DataValidations.Add(dvt, skipIntersectionsCheck: true); - if (dvs.AllowBlank != null) dvt.IgnoreBlanks = dvs.AllowBlank; - if (dvs.ShowDropDown != null) dvt.InCellDropdown = !dvs.ShowDropDown.Value; - if (dvs.ShowErrorMessage != null) dvt.ShowErrorMessage = dvs.ShowErrorMessage; - if (dvs.ShowInputMessage != null) dvt.ShowInputMessage = dvs.ShowInputMessage; - if (dvs.PromptTitle != null) dvt.InputTitle = dvs.PromptTitle; - if (dvs.Prompt != null) dvt.InputMessage = dvs.Prompt; - if (dvs.ErrorTitle != null) dvt.ErrorTitle = dvs.ErrorTitle; - if (dvs.Error != null) dvt.ErrorMessage = dvs.Error; - if (dvs.ErrorStyle != null) dvt.ErrorStyle = dvs.ErrorStyle.Value.ToClosedXml(); - if (dvs.Type != null) dvt.AllowedValues = dvs.Type.Value.ToClosedXml(); - if (dvs.Operator != null) dvt.Operator = dvs.Operator.Value.ToClosedXml(); - if (dvs.Formula1 != null) dvt.MinValue = dvs.Formula1.Text; - if (dvs.Formula2 != null) dvt.MaxValue = dvs.Formula2.Text; + if (dvs.AllowBlank != null) + { + dvt.IgnoreBlanks = dvs.AllowBlank; + } + + if (dvs.ShowDropDown != null) + { + dvt.InCellDropdown = !dvs.ShowDropDown.Value; + } + + if (dvs.ShowErrorMessage != null) + { + dvt.ShowErrorMessage = dvs.ShowErrorMessage; + } + + if (dvs.ShowInputMessage != null) + { + dvt.ShowInputMessage = dvs.ShowInputMessage; + } + + if (dvs.PromptTitle != null) + { + dvt.InputTitle = dvs.PromptTitle; + } + + if (dvs.Prompt != null) + { + dvt.InputMessage = dvs.Prompt; + } + + if (dvs.ErrorTitle != null) + { + dvt.ErrorTitle = dvs.ErrorTitle; + } + + if (dvs.Error != null) + { + dvt.ErrorMessage = dvs.Error; + } + + if (dvs.ErrorStyle != null) + { + dvt.ErrorStyle = dvs.ErrorStyle.Value.ToClosedXml(); + } + + if (dvs.Type != null) + { + dvt.AllowedValues = dvs.Type.Value.ToClosedXml(); + } + + if (dvs.Operator != null) + { + dvt.Operator = dvs.Operator.Value.ToClosedXml(); + } + + if (dvs.Formula1 != null) + { + dvt.MinValue = dvs.Formula1.Text; + } + + if (dvs.Formula2 != null) + { + dvt.MaxValue = dvs.Formula2.Text; + } } } } @@ -2560,54 +3340,78 @@ private static void LoadDataValidations(DataValidations dataValidations, XLWorks /// // https://msdn.microsoft.com/en-us/library/documentformat.openxml.spreadsheet.conditionalformattingrule%28v=office.15%29.aspx?f=255&MSPPError=-2147217396 private void LoadConditionalFormatting(ConditionalFormatting conditionalFormatting, XLWorksheet ws, - Dictionary differentialFormats) + Dictionary differentialFormats) { - if (conditionalFormatting == null) return; + if (conditionalFormatting == null) + { + return; + } foreach (var fr in conditionalFormatting.Elements()) { var ranges = conditionalFormatting.SequenceOfReferences.Items .Select(sor => ws.Range(sor.Value)); - var conditionalFormat = new XLConditionalFormat(ranges); - - conditionalFormat.StopIfTrue = OpenXmlHelper.GetBooleanValueAsBool(fr.StopIfTrue, false); + var conditionalFormat = new XLConditionalFormat(ranges) + { + StopIfTrue = OpenXmlHelper.GetBooleanValueAsBool(fr.StopIfTrue, false) + }; if (fr.FormatId != null) { - LoadFont(differentialFormats[(Int32)fr.FormatId.Value].Font, conditionalFormat.Style.Font); - LoadFill(differentialFormats[(Int32)fr.FormatId.Value].Fill, conditionalFormat.Style.Fill, + LoadFont(differentialFormats[(int)fr.FormatId.Value].Font, conditionalFormat.Style.Font); + LoadFill(differentialFormats[(int)fr.FormatId.Value].Fill, conditionalFormat.Style.Fill, differentialFillFormat: true); - LoadBorder(differentialFormats[(Int32)fr.FormatId.Value].Border, conditionalFormat.Style.Border); - LoadNumberFormat(differentialFormats[(Int32)fr.FormatId.Value].NumberingFormat, + LoadBorder(differentialFormats[(int)fr.FormatId.Value].Border, conditionalFormat.Style.Border); + LoadNumberFormat(differentialFormats[(int)fr.FormatId.Value].NumberingFormat, conditionalFormat.Style.NumberFormat); } // The conditional formatting type is compulsory. If it doesn't exist, skip the entire rule. - if (fr.Type == null) continue; + if (fr.Type == null) + { + continue; + } + conditionalFormat.ConditionalFormatType = fr.Type.Value.ToClosedXml(); - conditionalFormat.OriginalPriority = fr.Priority?.Value ?? Int32.MaxValue; + conditionalFormat.OriginalPriority = fr.Priority?.Value ?? int.MaxValue; if (conditionalFormat.ConditionalFormatType == XLConditionalFormatType.CellIs && fr.Operator != null) + { conditionalFormat.Operator = fr.Operator.Value.ToClosedXml(); + } - if (!String.IsNullOrWhiteSpace(fr.Text)) + if (!string.IsNullOrWhiteSpace(fr.Text)) + { conditionalFormat.Values.Add(GetFormula(fr.Text.Value)); + } if (conditionalFormat.ConditionalFormatType == XLConditionalFormatType.Top10) { if (fr.Percent != null) + { conditionalFormat.Percent = fr.Percent.Value; + } + if (fr.Bottom != null) + { conditionalFormat.Bottom = fr.Bottom.Value; + } + if (fr.Rank != null) + { conditionalFormat.Values.Add(GetFormula(fr.Rank.Value.ToString())); + } } else if (conditionalFormat.ConditionalFormatType == XLConditionalFormatType.TimePeriod) { if (fr.TimePeriod != null) + { conditionalFormat.TimePeriod = fr.TimePeriod.Value.ToClosedXml(); + } else + { conditionalFormat.TimePeriod = XLTimePeriod.Yesterday; + } } if (fr.Elements().Any()) @@ -2619,11 +3423,15 @@ private void LoadConditionalFormatting(ConditionalFormatting conditionalFormatti { var dataBar = fr.Elements().First(); if (dataBar.ShowValue != null) + { conditionalFormat.ShowBarOnly = !dataBar.ShowValue.Value; + } var id = fr.Descendants().FirstOrDefault(); - if (id != null && id.Text != null && !String.IsNullOrWhiteSpace(id.Text)) + if (id != null && id.Text != null && !string.IsNullOrWhiteSpace(id.Text)) + { conditionalFormat.Id = new Guid(id.Text.Substring(1, id.Text.Length - 2)); + } ExtractConditionalFormatValueObjects(conditionalFormat, dataBar); } @@ -2631,14 +3439,23 @@ private void LoadConditionalFormatting(ConditionalFormatting conditionalFormatti { var iconSet = fr.Elements().First(); if (iconSet.ShowValue != null) + { conditionalFormat.ShowIconOnly = !iconSet.ShowValue.Value; + } + if (iconSet.Reverse != null) + { conditionalFormat.ReverseIconOrder = iconSet.Reverse.Value; + } if (iconSet.IconSetValue != null) + { conditionalFormat.IconSetStyle = iconSet.IconSetValue.Value.ToClosedXml(); + } else + { conditionalFormat.IconSetStyle = XLIconSetStyle.ThreeTrafficLights1; + } ExtractConditionalFormatValueObjects(conditionalFormat, iconSet); } @@ -2684,59 +3501,156 @@ private void LoadExtensions(WorksheetExtensionList extensions, XLWorksheet ws) } foreach (var slg in extensions - .Descendants() - .SelectMany(sparklineGroups => sparklineGroups.Descendants())) + .Descendants() + .SelectMany(sparklineGroups => sparklineGroups.Descendants())) { var xlSparklineGroup = (ws.SparklineGroups as XLSparklineGroups).Add(); if (slg.Formula != null) + { xlSparklineGroup.DateRange = Range(slg.Formula.Text); + } var xlSparklineStyle = xlSparklineGroup.Style; - if (slg.FirstMarkerColor != null) xlSparklineStyle.FirstMarkerColor = slg.FirstMarkerColor.ToClosedXMLColor(); - if (slg.LastMarkerColor != null) xlSparklineStyle.LastMarkerColor = slg.LastMarkerColor.ToClosedXMLColor(); - if (slg.HighMarkerColor != null) xlSparklineStyle.HighMarkerColor = slg.HighMarkerColor.ToClosedXMLColor(); - if (slg.LowMarkerColor != null) xlSparklineStyle.LowMarkerColor = slg.LowMarkerColor.ToClosedXMLColor(); - if (slg.SeriesColor != null) xlSparklineStyle.SeriesColor = slg.SeriesColor.ToClosedXMLColor(); - if (slg.NegativeColor != null) xlSparklineStyle.NegativeColor = slg.NegativeColor.ToClosedXMLColor(); - if (slg.MarkersColor != null) xlSparklineStyle.MarkersColor = slg.MarkersColor.ToClosedXMLColor(); + if (slg.FirstMarkerColor != null) + { + xlSparklineStyle.FirstMarkerColor = slg.FirstMarkerColor.ToClosedXMLColor(); + } + + if (slg.LastMarkerColor != null) + { + xlSparklineStyle.LastMarkerColor = slg.LastMarkerColor.ToClosedXMLColor(); + } + + if (slg.HighMarkerColor != null) + { + xlSparklineStyle.HighMarkerColor = slg.HighMarkerColor.ToClosedXMLColor(); + } + + if (slg.LowMarkerColor != null) + { + xlSparklineStyle.LowMarkerColor = slg.LowMarkerColor.ToClosedXMLColor(); + } + + if (slg.SeriesColor != null) + { + xlSparklineStyle.SeriesColor = slg.SeriesColor.ToClosedXMLColor(); + } + + if (slg.NegativeColor != null) + { + xlSparklineStyle.NegativeColor = slg.NegativeColor.ToClosedXMLColor(); + } + + if (slg.MarkersColor != null) + { + xlSparklineStyle.MarkersColor = slg.MarkersColor.ToClosedXMLColor(); + } + xlSparklineGroup.Style = xlSparklineStyle; - if (slg.DisplayHidden != null) xlSparklineGroup.DisplayHidden = slg.DisplayHidden; - if (slg.LineWeight != null) xlSparklineGroup.LineWeight = slg.LineWeight; - if (slg.Type != null) xlSparklineGroup.Type = slg.Type.Value.ToClosedXml(); - if (slg.DisplayEmptyCellsAs != null) xlSparklineGroup.DisplayEmptyCellsAs = slg.DisplayEmptyCellsAs.Value.ToClosedXml(); + if (slg.DisplayHidden != null) + { + xlSparklineGroup.DisplayHidden = slg.DisplayHidden; + } + + if (slg.LineWeight != null) + { + xlSparklineGroup.LineWeight = slg.LineWeight; + } + + if (slg.Type != null) + { + xlSparklineGroup.Type = slg.Type.Value.ToClosedXml(); + } + + if (slg.DisplayEmptyCellsAs != null) + { + xlSparklineGroup.DisplayEmptyCellsAs = slg.DisplayEmptyCellsAs.Value.ToClosedXml(); + } xlSparklineGroup.ShowMarkers = XLSparklineMarkers.None; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.Markers, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.Markers; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.High, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.HighPoint; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.Low, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.LowPoint; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.First, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.FirstPoint; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.Last, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.LastPoint; - if (OpenXmlHelper.GetBooleanValueAsBool(slg.Negative, false)) xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.NegativePoints; - - if (slg.AxisColor != null) xlSparklineGroup.HorizontalAxis.Color = ExtractColor(slg.AxisColor.Rgb.Value); - if (slg.DisplayXAxis != null) xlSparklineGroup.HorizontalAxis.IsVisible = slg.DisplayXAxis; - if (slg.RightToLeft != null) xlSparklineGroup.HorizontalAxis.RightToLeft = slg.RightToLeft; - - if (slg.ManualMax != null) xlSparklineGroup.VerticalAxis.ManualMax = slg.ManualMax; - if (slg.ManualMin != null) xlSparklineGroup.VerticalAxis.ManualMin = slg.ManualMin; - if (slg.MinAxisType != null) xlSparklineGroup.VerticalAxis.MinAxisType = slg.MinAxisType.Value.ToClosedXml(); - if (slg.MaxAxisType != null) xlSparklineGroup.VerticalAxis.MaxAxisType = slg.MaxAxisType.Value.ToClosedXml(); - - slg.Descendants().SelectMany(sls => sls.Descendants()) + if (OpenXmlHelper.GetBooleanValueAsBool(slg.Markers, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.Markers; + } + + if (OpenXmlHelper.GetBooleanValueAsBool(slg.High, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.HighPoint; + } + + if (OpenXmlHelper.GetBooleanValueAsBool(slg.Low, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.LowPoint; + } + + if (OpenXmlHelper.GetBooleanValueAsBool(slg.First, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.FirstPoint; + } + + if (OpenXmlHelper.GetBooleanValueAsBool(slg.Last, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.LastPoint; + } + + if (OpenXmlHelper.GetBooleanValueAsBool(slg.Negative, false)) + { + xlSparklineGroup.ShowMarkers |= XLSparklineMarkers.NegativePoints; + } + + if (slg.AxisColor != null) + { + xlSparklineGroup.HorizontalAxis.Color = ExtractColor(slg.AxisColor.Rgb.Value); + } + + if (slg.DisplayXAxis != null) + { + xlSparklineGroup.HorizontalAxis.IsVisible = slg.DisplayXAxis; + } + + if (slg.RightToLeft != null) + { + xlSparklineGroup.HorizontalAxis.RightToLeft = slg.RightToLeft; + } + + if (slg.ManualMax != null) + { + xlSparklineGroup.VerticalAxis.ManualMax = slg.ManualMax; + } + + if (slg.ManualMin != null) + { + xlSparklineGroup.VerticalAxis.ManualMin = slg.ManualMin; + } + + if (slg.MinAxisType != null) + { + xlSparklineGroup.VerticalAxis.MinAxisType = slg.MinAxisType.Value.ToClosedXml(); + } + + if (slg.MaxAxisType != null) + { + xlSparklineGroup.VerticalAxis.MaxAxisType = slg.MaxAxisType.Value.ToClosedXml(); + } + + slg.Descendants().SelectMany(sls => sls.Descendants()) .ForEach(sl => xlSparklineGroup.Add(sl.ReferenceSequence?.Text, sl.Formula?.Text)); } } private static void LoadWorkbookProtection(WorkbookProtection wp, XLWorkbook wb) { - if (wp == null) return; + if (wp == null) + { + return; + } wb.Protection.IsProtected = true; var algorithmName = wp.WorkbookAlgorithmName?.Value ?? string.Empty; - if (String.IsNullOrEmpty(algorithmName)) + if (string.IsNullOrEmpty(algorithmName)) { wb.Protection.PasswordHash = wp.WorkbookPassword?.Value ?? string.Empty; wb.Protection.Base64EncodedSalt = string.Empty; @@ -2753,11 +3667,13 @@ private static void LoadWorkbookProtection(WorkbookProtection wp, XLWorkbook wb) wb.Protection.AllowElement(XLWorkbookProtectionElements.Windows, !OpenXmlHelper.GetBooleanValueAsBool(wp.LockWindows, false)); } - private static XLFormula GetFormula(String value) + private static XLFormula GetFormula(string value) { - var formula = new XLFormula(); - formula._value = value; - formula.IsFormula = !(value[0] == '"' && value.EndsWith("\"")); + var formula = new XLFormula + { + _value = value, + IsFormula = !(value[0] == '"' && value.EndsWith("\"")) + }; return formula; } @@ -2766,18 +3682,29 @@ private void ExtractConditionalFormatValueObjects(XLConditionalFormat conditiona foreach (var c in element.Elements()) { if (c.Type != null) + { conditionalFormat.ContentTypes.Add(c.Type.Value.ToClosedXml()); + } + if (c.Val != null) + { conditionalFormat.Values.Add(new XLFormula { Value = c.Val.Value }); + } else + { conditionalFormat.Values.Add(null); + } if (c.GreaterThanOrEqual != null) + { conditionalFormat.IconSetOperators.Add(c.GreaterThanOrEqual.Value ? XLCFIconSetOperator.EqualOrGreaterThan : XLCFIconSetOperator.GreaterThan); + } else + { conditionalFormat.IconSetOperators.Add(XLCFIconSetOperator.EqualOrGreaterThan); + } } - foreach (var c in element.Elements()) + foreach (var c in element.Elements()) { conditionalFormat.Colors.Add(c.ToClosedXMLColor(_colorList)); } @@ -2785,27 +3712,42 @@ private void ExtractConditionalFormatValueObjects(XLConditionalFormat conditiona private static void LoadHyperlinks(Hyperlinks hyperlinks, WorksheetPart worksheetPart, XLWorksheet ws) { - var hyperlinkDictionary = new Dictionary(); + var hyperlinkDictionary = new Dictionary(); if (worksheetPart.HyperlinkRelationships != null) + { hyperlinkDictionary = worksheetPart.HyperlinkRelationships.ToDictionary(hr => hr.Id, hr => hr.Uri); + } - if (hyperlinks == null) return; + if (hyperlinks == null) + { + return; + } - foreach (Hyperlink hl in hyperlinks.Elements()) + foreach (var hl in hyperlinks.Elements()) { - if (hl.Reference.Value.Equals("#REF")) continue; - String tooltip = hl.Tooltip != null ? hl.Tooltip.Value : String.Empty; + if (hl.Reference.Value.Equals("#REF")) + { + continue; + } + + var tooltip = hl.Tooltip != null ? hl.Tooltip.Value : string.Empty; var xlRange = ws.Range(hl.Reference.Value); foreach (XLCell xlCell in xlRange.Cells()) { xlCell.SettingHyperlink = true; if (hl.Id != null) + { xlCell.SetHyperlink(new XLHyperlink(hyperlinkDictionary[hl.Id], tooltip)); + } else if (hl.Location != null) + { xlCell.SetHyperlink(new XLHyperlink(hl.Location.Value, tooltip)); + } else + { xlCell.SetHyperlink(new XLHyperlink(hl.Reference.Value, tooltip)); + } xlCell.SettingHyperlink = false; } @@ -2814,29 +3756,42 @@ private static void LoadHyperlinks(Hyperlinks hyperlinks, WorksheetPart workshee private static void LoadColumnBreaks(ColumnBreaks columnBreaks, XLWorksheet ws) { - if (columnBreaks == null) return; + if (columnBreaks == null) + { + return; + } - foreach (Break columnBreak in columnBreaks.Elements().Where(columnBreak => columnBreak.Id != null)) + foreach (var columnBreak in columnBreaks.Elements().Where(columnBreak => columnBreak.Id != null)) { - ws.PageSetup.ColumnBreaks.Add(Int32.Parse(columnBreak.Id.InnerText)); + ws.PageSetup.ColumnBreaks.Add(int.Parse(columnBreak.Id.InnerText)); } } private static void LoadRowBreaks(RowBreaks rowBreaks, XLWorksheet ws) { - if (rowBreaks == null) return; + if (rowBreaks == null) + { + return; + } - foreach (Break rowBreak in rowBreaks.Elements()) - ws.PageSetup.RowBreaks.Add(Int32.Parse(rowBreak.Id.InnerText)); + foreach (var rowBreak in rowBreaks.Elements()) + { + ws.PageSetup.RowBreaks.Add(int.Parse(rowBreak.Id.InnerText)); + } } private void LoadSheetProperties(SheetProperties sheetProperty, XLWorksheet ws, out PageSetupProperties pageSetupProperties) { pageSetupProperties = null; - if (sheetProperty == null) return; + if (sheetProperty == null) + { + return; + } if (sheetProperty.TabColor != null) + { ws.TabColor = sheetProperty.TabColor.ToClosedXMLColor(_colorList); + } if (sheetProperty.OutlineProperties != null) { @@ -2856,169 +3811,339 @@ private void LoadSheetProperties(SheetProperties sheetProperty, XLWorksheet ws, } if (sheetProperty.PageSetupProperties != null) + { pageSetupProperties = sheetProperty.PageSetupProperties; + } } private static void LoadHeaderFooter(HeaderFooter headerFooter, XLWorksheet ws) { - if (headerFooter == null) return; + if (headerFooter == null) + { + return; + } if (headerFooter.AlignWithMargins != null) + { ws.PageSetup.AlignHFWithMargins = headerFooter.AlignWithMargins; + } + if (headerFooter.ScaleWithDoc != null) + { ws.PageSetup.ScaleHFWithDocument = headerFooter.ScaleWithDoc; + } if (headerFooter.DifferentFirst != null) + { ws.PageSetup.DifferentFirstPageOnHF = headerFooter.DifferentFirst; + } + if (headerFooter.DifferentOddEven != null) + { ws.PageSetup.DifferentOddEvenPagesOnHF = headerFooter.DifferentOddEven; + } // Footers var xlFooter = (XLHeaderFooter)ws.PageSetup.Footer; var evenFooter = headerFooter.EvenFooter; if (evenFooter != null) + { xlFooter.SetInnerText(XLHFOccurrence.EvenPages, evenFooter.Text); + } + var oddFooter = headerFooter.OddFooter; if (oddFooter != null) + { xlFooter.SetInnerText(XLHFOccurrence.OddPages, oddFooter.Text); + } + var firstFooter = headerFooter.FirstFooter; if (firstFooter != null) + { xlFooter.SetInnerText(XLHFOccurrence.FirstPage, firstFooter.Text); + } // Headers var xlHeader = (XLHeaderFooter)ws.PageSetup.Header; var evenHeader = headerFooter.EvenHeader; if (evenHeader != null) + { xlHeader.SetInnerText(XLHFOccurrence.EvenPages, evenHeader.Text); + } + var oddHeader = headerFooter.OddHeader; if (oddHeader != null) + { xlHeader.SetInnerText(XLHFOccurrence.OddPages, oddHeader.Text); + } + var firstHeader = headerFooter.FirstHeader; if (firstHeader != null) + { xlHeader.SetInnerText(XLHFOccurrence.FirstPage, firstHeader.Text); - - ((XLHeaderFooter)ws.PageSetup.Header).SetAsInitial(); + } ((XLHeaderFooter)ws.PageSetup.Header).SetAsInitial(); ((XLHeaderFooter)ws.PageSetup.Footer).SetAsInitial(); } private static void LoadPageSetup(PageSetup pageSetup, XLWorksheet ws, PageSetupProperties pageSetupProperties) { - if (pageSetup == null) return; + if (pageSetup == null) + { + return; + } if (pageSetup.PaperSize != null) - ws.PageSetup.PaperSize = (XLPaperSize)Int32.Parse(pageSetup.PaperSize.InnerText); + { + ws.PageSetup.PaperSize = (XLPaperSize)int.Parse(pageSetup.PaperSize.InnerText); + } + if (pageSetup.Scale != null) - ws.PageSetup.Scale = Int32.Parse(pageSetup.Scale.InnerText); + { + ws.PageSetup.Scale = int.Parse(pageSetup.Scale.InnerText); + } + if (pageSetupProperties != null && pageSetupProperties.FitToPage != null && pageSetupProperties.FitToPage.Value) { if (pageSetup.FitToWidth == null) + { ws.PageSetup.PagesWide = 1; + } else - ws.PageSetup.PagesWide = Int32.Parse(pageSetup.FitToWidth.InnerText); + { + ws.PageSetup.PagesWide = int.Parse(pageSetup.FitToWidth.InnerText); + } if (pageSetup.FitToHeight == null) + { ws.PageSetup.PagesTall = 1; + } else - ws.PageSetup.PagesTall = Int32.Parse(pageSetup.FitToHeight.InnerText); + { + ws.PageSetup.PagesTall = int.Parse(pageSetup.FitToHeight.InnerText); + } } if (pageSetup.PageOrder != null) + { ws.PageSetup.PageOrder = pageSetup.PageOrder.Value.ToClosedXml(); + } + if (pageSetup.Orientation != null) + { ws.PageSetup.PageOrientation = pageSetup.Orientation.Value.ToClosedXml(); + } + if (pageSetup.BlackAndWhite != null) + { ws.PageSetup.BlackAndWhite = pageSetup.BlackAndWhite; + } + if (pageSetup.Draft != null) + { ws.PageSetup.DraftQuality = pageSetup.Draft; + } + if (pageSetup.CellComments != null) + { ws.PageSetup.ShowComments = pageSetup.CellComments.Value.ToClosedXml(); + } + if (pageSetup.Errors != null) + { ws.PageSetup.PrintErrorValue = pageSetup.Errors.Value.ToClosedXml(); - if (pageSetup.HorizontalDpi != null) ws.PageSetup.HorizontalDpi = (Int32)pageSetup.HorizontalDpi.Value; - if (pageSetup.VerticalDpi != null) ws.PageSetup.VerticalDpi = (Int32)pageSetup.VerticalDpi.Value; + } + + if (pageSetup.HorizontalDpi != null) + { + ws.PageSetup.HorizontalDpi = (int)pageSetup.HorizontalDpi.Value; + } + + if (pageSetup.VerticalDpi != null) + { + ws.PageSetup.VerticalDpi = (int)pageSetup.VerticalDpi.Value; + } + if (pageSetup.FirstPageNumber?.HasValue ?? false) + { ws.PageSetup.FirstPageNumber = pageSetup.FirstPageNumber.Value; + } } private static void LoadPageMargins(PageMargins pageMargins, XLWorksheet ws) { - if (pageMargins == null) return; + if (pageMargins == null) + { + return; + } if (pageMargins.Bottom != null) + { ws.PageSetup.Margins.Bottom = pageMargins.Bottom; + } + if (pageMargins.Footer != null) + { ws.PageSetup.Margins.Footer = pageMargins.Footer; + } + if (pageMargins.Header != null) + { ws.PageSetup.Margins.Header = pageMargins.Header; + } + if (pageMargins.Left != null) + { ws.PageSetup.Margins.Left = pageMargins.Left; + } + if (pageMargins.Right != null) + { ws.PageSetup.Margins.Right = pageMargins.Right; + } + if (pageMargins.Top != null) + { ws.PageSetup.Margins.Top = pageMargins.Top; + } } private static void LoadPrintOptions(PrintOptions printOptions, XLWorksheet ws) { - if (printOptions == null) return; + if (printOptions == null) + { + return; + } if (printOptions.GridLines != null) + { ws.PageSetup.ShowGridlines = printOptions.GridLines; + } + if (printOptions.HorizontalCentered != null) + { ws.PageSetup.CenterHorizontally = printOptions.HorizontalCentered; + } + if (printOptions.VerticalCentered != null) + { ws.PageSetup.CenterVertically = printOptions.VerticalCentered; + } + if (printOptions.Headings != null) + { ws.PageSetup.ShowRowAndColumnHeadings = printOptions.Headings; + } } private static void LoadSheetViews(SheetViews sheetViews, XLWorksheet ws) { - if (sheetViews == null) return; + if (sheetViews == null) + { + return; + } var sheetView = sheetViews.Elements().FirstOrDefault(); - if (sheetView == null) return; + if (sheetView == null) + { + return; + } + + if (sheetView.RightToLeft != null) + { + ws.RightToLeft = sheetView.RightToLeft.Value; + } + + if (sheetView.ShowFormulas != null) + { + ws.ShowFormulas = sheetView.ShowFormulas.Value; + } + + if (sheetView.ShowGridLines != null) + { + ws.ShowGridLines = sheetView.ShowGridLines.Value; + } - if (sheetView.RightToLeft != null) ws.RightToLeft = sheetView.RightToLeft.Value; - if (sheetView.ShowFormulas != null) ws.ShowFormulas = sheetView.ShowFormulas.Value; - if (sheetView.ShowGridLines != null) ws.ShowGridLines = sheetView.ShowGridLines.Value; if (sheetView.ShowOutlineSymbols != null) + { ws.ShowOutlineSymbols = sheetView.ShowOutlineSymbols.Value; - if (sheetView.ShowRowColHeaders != null) ws.ShowRowColHeaders = sheetView.ShowRowColHeaders.Value; - if (sheetView.ShowRuler != null) ws.ShowRuler = sheetView.ShowRuler.Value; - if (sheetView.ShowWhiteSpace != null) ws.ShowWhiteSpace = sheetView.ShowWhiteSpace.Value; - if (sheetView.ShowZeros != null) ws.ShowZeros = sheetView.ShowZeros.Value; - if (sheetView.TabSelected != null) ws.TabSelected = sheetView.TabSelected.Value; + } + + if (sheetView.ShowRowColHeaders != null) + { + ws.ShowRowColHeaders = sheetView.ShowRowColHeaders.Value; + } + + if (sheetView.ShowRuler != null) + { + ws.ShowRuler = sheetView.ShowRuler.Value; + } + + if (sheetView.ShowWhiteSpace != null) + { + ws.ShowWhiteSpace = sheetView.ShowWhiteSpace.Value; + } + + if (sheetView.ShowZeros != null) + { + ws.ShowZeros = sheetView.ShowZeros.Value; + } + + if (sheetView.TabSelected != null) + { + ws.TabSelected = sheetView.TabSelected.Value; + } var selection = sheetView.Elements().FirstOrDefault(); if (selection != null) { if (selection.SequenceOfReferences != null) + { ws.Ranges(selection.SequenceOfReferences.InnerText.Replace(" ", ",")).Select(); + } if (selection.ActiveCell != null) + { ws.Cell(selection.ActiveCell).SetActive(); + } } if (sheetView.ZoomScale != null) + { ws.SheetView.ZoomScale = (int)UInt32Value.ToUInt32(sheetView.ZoomScale); + } + if (sheetView.ZoomScaleNormal != null) + { ws.SheetView.ZoomScaleNormal = (int)UInt32Value.ToUInt32(sheetView.ZoomScaleNormal); + } + if (sheetView.ZoomScalePageLayoutView != null) + { ws.SheetView.ZoomScalePageLayoutView = (int)UInt32Value.ToUInt32(sheetView.ZoomScalePageLayoutView); + } + if (sheetView.ZoomScaleSheetLayoutView != null) + { ws.SheetView.ZoomScaleSheetLayoutView = (int)UInt32Value.ToUInt32(sheetView.ZoomScaleSheetLayoutView); + } var pane = sheetView.Elements().FirstOrDefault(); if (new[] { PaneStateValues.Frozen, PaneStateValues.FrozenSplit }.Contains(pane?.State?.Value ?? PaneStateValues.Split)) { if (pane.HorizontalSplit != null) - ws.SheetView.SplitColumn = (Int32)pane.HorizontalSplit.Value; + { + ws.SheetView.SplitColumn = (int)pane.HorizontalSplit.Value; + } + if (pane.VerticalSplit != null) - ws.SheetView.SplitRow = (Int32)pane.VerticalSplit.Value; + { + ws.SheetView.SplitRow = (int)pane.VerticalSplit.Value; + } } if (XLHelper.IsValidA1Address(sheetView.TopLeftCell)) + { ws.SheetView.TopLeftCellAddress = ws.Cell(sheetView.TopLeftCell.Value).Address; + } } private void SetProperties(SpreadsheetDocument dSpreadsheet) @@ -3028,9 +4153,15 @@ private void SetProperties(SpreadsheetDocument dSpreadsheet) Properties.Category = p.Category; Properties.Comments = p.Description; if (p.Created != null) + { Properties.Created = p.Created.Value; + } + if (p.Modified != null) + { Properties.Modified = p.Modified.Value; + } + Properties.Keywords = p.Keywords; Properties.LastModifiedBy = p.LastModifiedBy; Properties.Status = p.ContentStatus; @@ -3038,10 +4169,13 @@ private void SetProperties(SpreadsheetDocument dSpreadsheet) Properties.Title = p.Title; } - private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, Fills fills, Borders borders, + private void ApplyStyle(IXLStylized xlStylized, int styleIndex, Stylesheet s, Fills fills, Borders borders, Fonts fonts, NumberingFormats numberingFormats) { - if (s == null) return; //No Stylesheet, no Styles + if (s == null) + { + return; //No Stylesheet, no Styles + } var cellFormat = (CellFormat)s.CellFormats.ElementAt(styleIndex); @@ -3054,7 +4188,9 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, var protection = cellFormat.Protection; if (protection == null) + { xlStyle.Protection = XLProtectionValue.Default.Key; + } else { xlStyle.Protection = new XLProtectionKey @@ -3069,7 +4205,7 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, if (UInt32HasValue(cellFormat.FillId)) { - var fill = (Fill)fills.ElementAt((Int32)cellFormat.FillId.Value); + var fill = (Fill)fills.ElementAt((int)cellFormat.FillId.Value); if (fill.PatternFill != null) { LoadFill(fill, xlStylized.InnerStyle.Fill, differentialFillFormat: false); @@ -3082,34 +4218,57 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, { var xlAlignment = xlStyle.Alignment; if (alignment.Horizontal != null) + { xlAlignment.Horizontal = alignment.Horizontal.Value.ToClosedXml(); + } + if (alignment.Indent != null && alignment.Indent != 0) - xlAlignment.Indent = Int32.Parse(alignment.Indent.ToString()); + { + xlAlignment.Indent = int.Parse(alignment.Indent.ToString()); + } + if (alignment.JustifyLastLine != null) + { xlAlignment.JustifyLastLine = alignment.JustifyLastLine; + } + if (alignment.ReadingOrder != null) { xlAlignment.ReadingOrder = - (XLAlignmentReadingOrderValues)Int32.Parse(alignment.ReadingOrder.ToString()); + (XLAlignmentReadingOrderValues)int.Parse(alignment.ReadingOrder.ToString()); } if (alignment.RelativeIndent != null) + { xlAlignment.RelativeIndent = alignment.RelativeIndent; + } + if (alignment.ShrinkToFit != null) + { xlAlignment.ShrinkToFit = alignment.ShrinkToFit; + } + if (alignment.TextRotation != null) - xlAlignment.TextRotation = (Int32)alignment.TextRotation.Value; + { + xlAlignment.TextRotation = (int)alignment.TextRotation.Value; + } + if (alignment.Vertical != null) + { xlAlignment.Vertical = alignment.Vertical.Value.ToClosedXml(); + } + if (alignment.WrapText != null) + { xlAlignment.WrapText = alignment.WrapText; + } xlStyle.Alignment = xlAlignment; } if (UInt32HasValue(cellFormat.BorderId)) { - uint borderId = cellFormat.BorderId.Value; - var border = (Border)borders.ElementAt((Int32)borderId); + var borderId = cellFormat.BorderId.Value; + var border = (Border)borders.ElementAt((int)borderId); var xlBorder = xlStyle.Border; if (border != null) { @@ -3117,46 +4276,76 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, if (bottomBorder != null) { if (bottomBorder.Style != null) + { xlBorder.BottomBorder = bottomBorder.Style.Value.ToClosedXml(); + } if (bottomBorder.Color != null) + { xlBorder.BottomBorderColor = bottomBorder.Color.ToClosedXMLColor(_colorList).Key; + } } var topBorder = border.TopBorder; if (topBorder != null) { if (topBorder.Style != null) + { xlBorder.TopBorder = topBorder.Style.Value.ToClosedXml(); + } + if (topBorder.Color != null) + { xlBorder.TopBorderColor = topBorder.Color.ToClosedXMLColor(_colorList).Key; + } } var leftBorder = border.LeftBorder; if (leftBorder != null) { if (leftBorder.Style != null) + { xlBorder.LeftBorder = leftBorder.Style.Value.ToClosedXml(); + } + if (leftBorder.Color != null) + { xlBorder.LeftBorderColor = leftBorder.Color.ToClosedXMLColor(_colorList).Key; + } } var rightBorder = border.RightBorder; if (rightBorder != null) { if (rightBorder.Style != null) + { xlBorder.RightBorder = rightBorder.Style.Value.ToClosedXml(); + } + if (rightBorder.Color != null) + { xlBorder.RightBorderColor = rightBorder.Color.ToClosedXMLColor(_colorList).Key; + } } var diagonalBorder = border.DiagonalBorder; if (diagonalBorder != null) { if (diagonalBorder.Style != null) + { xlBorder.DiagonalBorder = diagonalBorder.Style.Value.ToClosedXml(); + } + if (diagonalBorder.Color != null) + { xlBorder.DiagonalBorderColor = diagonalBorder.Color.ToClosedXMLColor(_colorList).Key; + } + if (border.DiagonalDown != null) + { xlBorder.DiagonalDown = border.DiagonalDown; + } + if (border.DiagonalUp != null) + { xlBorder.DiagonalUp = border.DiagonalUp; + } } xlStyle.Border = xlBorder; @@ -3166,7 +4355,7 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, if (UInt32HasValue(cellFormat.FontId)) { var fontId = cellFormat.FontId; - var font = (DocumentFormat.OpenXml.Spreadsheet.Font)fonts.ElementAt((Int32)fontId.Value); + var font = (Font)fonts.ElementAt((int)fontId.Value); var xlFont = xlStyle.Font; if (font != null) @@ -3174,22 +4363,22 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, xlFont.Bold = GetBoolean(font.Bold); if (font.Color != null) + { xlFont.FontColor = font.Color.ToClosedXMLColor(_colorList).Key; + } - if (font.FontFamilyNumbering != null && (font.FontFamilyNumbering).Val != null) + if (font.FontFamilyNumbering != null && font.FontFamilyNumbering.Val != null) { xlFont.FontFamilyNumbering = - (XLFontFamilyNumberingValues)Int32.Parse((font.FontFamilyNumbering).Val.ToString()); + (XLFontFamilyNumberingValues)int.Parse(font.FontFamilyNumbering.Val.ToString()); } - if (font.FontName != null) + if (font.FontName != null && font.FontName.Val != null) { - if ((font.FontName).Val != null) - xlFont.FontName = (font.FontName).Val; + xlFont.FontName = font.FontName.Val; } - if (font.FontSize != null) + if (font.FontSize != null && font.FontSize.Val != null) { - if ((font.FontSize).Val != null) - xlFont.FontSize = (font.FontSize).Val; + xlFont.FontSize = font.FontSize.Val; } xlFont.Italic = GetBoolean(font.Italic); @@ -3199,14 +4388,14 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, if (font.Underline != null) { xlFont.Underline = font.Underline.Val != null - ? (font.Underline).Val.Value.ToClosedXml() + ? font.Underline.Val.Value.ToClosedXml() : XLFontUnderlineValues.Single; } if (font.VerticalTextAlignment != null) { xlFont.VerticalAlignment = font.VerticalTextAlignment.Val != null - ? (font.VerticalTextAlignment).Val.Value.ToClosedXml() + ? font.VerticalTextAlignment.Val.Value.ToClosedXml() : XLFontVerticalTextAlignmentValues.Baseline; } @@ -3218,17 +4407,13 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, { var numberFormatId = cellFormat.NumberFormatId; - string formatCode = String.Empty; - if (numberingFormats != null) - { - var numberingFormat = - numberingFormats.FirstOrDefault( + var formatCode = string.Empty; + if (numberingFormats != null && numberingFormats.FirstOrDefault( nf => ((NumberingFormat)nf).NumberFormatId != null && - ((NumberingFormat)nf).NumberFormatId.Value == numberFormatId) as NumberingFormat; - - if (numberingFormat != null && numberingFormat.FormatCode != null) - formatCode = numberingFormat.FormatCode.Value; + ((NumberingFormat)nf).NumberFormatId.Value == numberFormatId) is NumberingFormat numberingFormat && numberingFormat.FormatCode != null) + { + formatCode = numberingFormat.FormatCode.Value; } var xlNumberFormat = xlStyle.NumberFormat; @@ -3238,32 +4423,42 @@ private void ApplyStyle(IXLStylized xlStylized, Int32 styleIndex, Stylesheet s, xlNumberFormat.NumberFormatId = -1; } else - xlNumberFormat.NumberFormatId = (Int32)numberFormatId.Value; + { + xlNumberFormat.NumberFormatId = (int)numberFormatId.Value; + } + xlStyle.NumberFormat = xlNumberFormat; } //When loading columns we must propagate style to each column but not deeper. In other cases we do not propagate at all. if (xlStylized is IXLColumns columns) + { columns.Cast().ForEach(col => col.InnerStyle = new XLStyle(col, xlStyle)); + } else + { xlStylized.InnerStyle = new XLStyle(xlStylized, xlStyle); + } } - private static Boolean UInt32HasValue(UInt32Value value) + private static bool UInt32HasValue(UInt32Value value) { return value != null && value.HasValue; } - private static Boolean GetBoolean(BooleanPropertyType property) + private static bool GetBoolean(BooleanPropertyType property) { if (property != null) { if (property.Val != null) + { return property.Val; + } + return true; } return false; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs b/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs index 308ebe73e..2d8749b3e 100644 --- a/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs +++ b/ClosedXML/Excel/XLWorkbook_Save.NestedTypes.cs @@ -19,14 +19,14 @@ public SaveContext() SharedNumberFormats = new Dictionary(); SharedStyles = new Dictionary(); TableId = 0; - TableNames = new HashSet(); + TableNames = new HashSet(); } - public Dictionary DifferentialFormats { get; private set; } + public Dictionary DifferentialFormats { get; private set; } public IDictionary PivotTables { get; private set; } public RelIdGenerator RelIdGenerator { get; private set; } public Dictionary SharedFonts { get; private set; } - public Dictionary SharedNumberFormats { get; private set; } + public Dictionary SharedNumberFormats { get; private set; } public Dictionary SharedStyles { get; private set; } public uint TableId { get; set; } public HashSet TableNames { get; private set; } @@ -47,35 +47,35 @@ internal enum RelType internal sealed class RelIdGenerator { - private readonly Dictionary> _relIds = new Dictionary>(); + private readonly Dictionary> _relIds = new Dictionary>(); - public void AddValues(IEnumerable values, RelType relType) + public void AddValues(IEnumerable values, RelType relType) { - if (!_relIds.TryGetValue(relType, out List list)) + if (!_relIds.TryGetValue(relType, out var list)) { - list = new List(); + list = new List(); _relIds.Add(relType, list); } list.AddRange(values.Where(v => !list.Contains(v))); } - public String GetNext() + public string GetNext() { return GetNext(RelType.Workbook); } - public String GetNext(RelType relType) + public string GetNext(RelType relType) { - if (!_relIds.TryGetValue(relType, out List list)) + if (!_relIds.TryGetValue(relType, out var list)) { - list = new List(); + list = new List(); _relIds.Add(relType, list); } - Int32 id = list.Count + 1; + var id = list.Count + 1; while (true) { - String relId = String.Concat("rId", id); + var relId = string.Concat("rId", id); if (!list.Contains(relId)) { list.Add(relId); @@ -88,7 +88,9 @@ public String GetNext(RelType relType) public void Reset(RelType relType) { if (_relIds.ContainsKey(relType)) + { _relIds.Remove(relType); + } } } @@ -99,7 +101,7 @@ public void Reset(RelType relType) internal struct FontInfo { public XLFontValue Font; - public UInt32 FontId; + public uint FontId; }; #endregion Nested type: FontInfo @@ -109,7 +111,7 @@ internal struct FontInfo internal struct FillInfo { public XLFillValue Fill; - public UInt32 FillId; + public uint FillId; } #endregion Nested type: FillInfo @@ -119,7 +121,7 @@ internal struct FillInfo internal struct BorderInfo { public XLBorderValue Border; - public UInt32 BorderId; + public uint BorderId; } #endregion Nested type: BorderInfo @@ -129,7 +131,7 @@ internal struct BorderInfo internal struct NumberFormatInfo { public XLNumberFormatValue NumberFormat; - public Int32 NumberFormatId; + public int NumberFormatId; } #endregion Nested type: NumberFormatInfo @@ -138,13 +140,13 @@ internal struct NumberFormatInfo internal struct StyleInfo { - public UInt32 BorderId; - public UInt32 FillId; - public UInt32 FontId; - public Boolean IncludeQuotePrefix; - public Int32 NumberFormatId; + public uint BorderId; + public uint FillId; + public uint FontId; + public bool IncludeQuotePrefix; + public int NumberFormatId; public XLStyleValue Style; - public UInt32 StyleId; + public uint StyleId; } #endregion Nested type: StyleInfo @@ -154,14 +156,14 @@ internal struct StyleInfo internal struct PivotTableFieldInfo { public XLDataType DataType; - public Boolean MixedDataType; - public IEnumerable DistinctValues; - public Boolean IsTotallyBlankField; + public bool MixedDataType; + public IEnumerable DistinctValues; + public bool IsTotallyBlankField; } internal struct PivotTableInfo { - public IDictionary Fields; + public IDictionary Fields; public Guid Guid; } diff --git a/ClosedXML/Excel/XLWorkbook_Save.cs b/ClosedXML/Excel/XLWorkbook_Save.cs index f17597952..a0c77b576 100644 --- a/ClosedXML/Excel/XLWorkbook_Save.cs +++ b/ClosedXML/Excel/XLWorkbook_Save.cs @@ -1,5 +1,6 @@ using ClosedXML.Excel.ContentManagers; using ClosedXML.Excel.Exceptions; +using ClosedXML.Excel.Tables; using ClosedXML.Extensions; using ClosedXML.Utils; using DocumentFormat.OpenXml; @@ -12,6 +13,7 @@ using DocumentFormat.OpenXml.VariantTypes; using DocumentFormat.OpenXml.Vml.Office; using DocumentFormat.OpenXml.Vml.Spreadsheet; +using SkiaSharp; using System; using System.Collections.Generic; using System.Globalization; @@ -38,7 +40,6 @@ using Outline = DocumentFormat.OpenXml.Drawing.Outline; using Path = System.IO.Path; using PatternFill = DocumentFormat.OpenXml.Spreadsheet.PatternFill; -using Properties = DocumentFormat.OpenXml.ExtendedProperties.Properties; using RightBorder = DocumentFormat.OpenXml.Spreadsheet.RightBorder; using Run = DocumentFormat.OpenXml.Spreadsheet.Run; using RunProperties = DocumentFormat.OpenXml.Spreadsheet.RunProperties; @@ -55,9 +56,7 @@ namespace ClosedXML.Excel { public partial class XLWorkbook { - private const Double ColumnWidthOffset = 0.710625; - - //private Dictionary context.SharedStyles; + private const double ColumnWidthOffset = 0.710625; private static readonly EnumValue CvSharedString = new EnumValue(CellValues.SharedString); private static readonly EnumValue CvInlineString = new EnumValue(CellValues.InlineString); @@ -89,7 +88,7 @@ private static EnumValue GetCellValueType(XLCell xlCell) } } - private Boolean Validate(SpreadsheetDocument package) + private bool Validate(SpreadsheetDocument package) { var backupCulture = Thread.CurrentThread.CurrentCulture; @@ -113,10 +112,13 @@ private Boolean Validate(SpreadsheetDocument package) return true; } - private void CreatePackage(String filePath, SpreadsheetDocumentType spreadsheetDocumentType, SaveOptions options) + private void CreatePackage(string filePath, SpreadsheetDocumentType spreadsheetDocumentType, SaveOptions options) { var directoryName = Path.GetDirectoryName(filePath); - if (!string.IsNullOrWhiteSpace(directoryName)) Directory.CreateDirectory(directoryName); + if (!string.IsNullOrWhiteSpace(directoryName)) + { + Directory.CreateDirectory(directoryName); + } var package = File.Exists(filePath) ? SpreadsheetDocument.Open(filePath, true) @@ -130,7 +132,10 @@ private void CreatePackage(String filePath, SpreadsheetDocumentType spreadsheetD } CreateParts(package, options); - if (options.ValidatePackage) Validate(package); + if (options.ValidatePackage) + { + Validate(package); + } } } @@ -143,7 +148,10 @@ private void CreatePackage(Stream stream, bool newStream, SpreadsheetDocumentTyp using (package) { CreateParts(package, options); - if (options.ValidatePackage) Validate(package); + if (options.ValidatePackage) + { + Validate(package); + } } } @@ -151,17 +159,19 @@ private void CreatePackage(Stream stream, bool newStream, SpreadsheetDocumentTyp private void DeleteSheetAndDependencies(WorkbookPart wbPart, string sheetId) { //Get the SheetToDelete from workbook.xml - Sheet worksheet = wbPart.Workbook.Descendants().FirstOrDefault(s => s.Id == sheetId); + var worksheet = wbPart.Workbook.Descendants().FirstOrDefault(s => s.Id == sheetId); if (worksheet == null) + { return; + } string sheetName = worksheet.Name; // Get the pivot Table Parts var pvtTableCacheParts = wbPart.PivotTableCacheDefinitionParts; var pvtTableCacheDefinitionPart = new Dictionary(); - foreach (PivotTableCacheDefinitionPart Item in pvtTableCacheParts) + foreach (var Item in pvtTableCacheParts) { - PivotCacheDefinition pvtCacheDef = Item.PivotCacheDefinition; + var pvtCacheDef = Item.PivotCacheDefinition; //Check if this CacheSource is linked to SheetToDelete if (pvtCacheDef.Descendants().Any(cacheSource => cacheSource.WorksheetSource?.Sheet == sheetName)) { @@ -174,7 +184,7 @@ private void DeleteSheetAndDependencies(WorkbookPart wbPart, string sheetId) } // Remove the sheet reference from the workbook. - WorksheetPart worksheetPart = (WorksheetPart)(wbPart.GetPartById(sheetId)); + var worksheetPart = (WorksheetPart)wbPart.GetPartById(sheetId); worksheet.Remove(); // Delete the worksheet part. @@ -184,16 +194,18 @@ private void DeleteSheetAndDependencies(WorkbookPart wbPart, string sheetId) var definedNames = wbPart.Workbook.Descendants().FirstOrDefault(); if (definedNames != null) { - List defNamesToDelete = new List(); + var defNamesToDelete = new List(); foreach (var Item in definedNames.OfType()) { // This condition checks to delete only those names which are part of Sheet in question if (Item.Text.Contains(worksheet.Name + "!")) + { defNamesToDelete.Add(Item); + } } - foreach (DefinedName Item in defNamesToDelete) + foreach (var Item in defNamesToDelete) { Item.Remove(); } @@ -207,22 +219,28 @@ private void DeleteSheetAndDependencies(WorkbookPart wbPart, string sheetId) if (calChainPart != null) { var calChainEntries = calChainPart.CalculationChain.Descendants().Where(c => c.SheetId == sheetId); - List calcsToDelete = new List(); - foreach (CalculationCell Item in calChainEntries) + var calcsToDelete = new List(); + foreach (var Item in calChainEntries) + { calcsToDelete.Add(Item); + } - foreach (CalculationCell Item in calcsToDelete) + foreach (var Item in calcsToDelete) + { Item.Remove(); + } if (!calChainPart.CalculationChain.Any()) + { wbPart.DeletePart(calChainPart); + } } } // Adds child parts and generates content of the specified part. private void CreateParts(SpreadsheetDocument document, SaveOptions options) { - this.SuspendEvents(); + SuspendEvents(); var context = new SaveContext(); @@ -245,12 +263,12 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) // Ensure all RelId's have been added to the context context.RelIdGenerator.AddValues(workbookPart.Parts.Select(p => p.RelationshipId), RelType.Workbook); - context.RelIdGenerator.AddValues(WorksheetsInternal.Cast().Where(ws => !String.IsNullOrWhiteSpace(ws.RelId)).Select(ws => ws.RelId), RelType.Workbook); - context.RelIdGenerator.AddValues(WorksheetsInternal.Cast().Where(ws => !String.IsNullOrWhiteSpace(ws.LegacyDrawingId)).Select(ws => ws.LegacyDrawingId), RelType.Workbook); + context.RelIdGenerator.AddValues(WorksheetsInternal.Cast().Where(ws => !string.IsNullOrWhiteSpace(ws.RelId)).Select(ws => ws.RelId), RelType.Workbook); + context.RelIdGenerator.AddValues(WorksheetsInternal.Cast().Where(ws => !string.IsNullOrWhiteSpace(ws.LegacyDrawingId)).Select(ws => ws.LegacyDrawingId), RelType.Workbook); context.RelIdGenerator.AddValues(WorksheetsInternal .Cast() .SelectMany(ws => ws.Tables.Cast()) - .Where(t => !String.IsNullOrWhiteSpace(t.RelId)) + .Where(t => !string.IsNullOrWhiteSpace(t.RelId)) .Select(t => t.RelId), RelType.Workbook); var extendedFilePropertiesPart = document.ExtendedFilePropertiesPart ?? @@ -282,7 +300,9 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) foreach (var relId in cacheRelIds) { if (workbookPart.GetPartById(relId) is PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart) + { pivotTableCacheDefinitionPart.PivotCacheDefinition.CacheFields.RemoveAllChildren(); + } } foreach (var worksheet in WorksheetsInternal.Cast().OrderBy(w => w.Position)) @@ -290,14 +310,20 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) WorksheetPart worksheetPart; var wsRelId = worksheet.RelId; if (workbookPart.Parts.Any(p => p.RelationshipId == wsRelId)) + { worksheetPart = (WorksheetPart)workbookPart.GetPartById(wsRelId); + } else + { worksheetPart = workbookPart.AddNewPart(wsRelId); + } context.RelIdGenerator.AddValues(worksheetPart.HyperlinkRelationships.Select(hr => hr.Id), RelType.Workbook); context.RelIdGenerator.AddValues(worksheetPart.Parts.Select(p => p.RelationshipId), RelType.Workbook); if (worksheetPart.DrawingsPart != null) + { context.RelIdGenerator.AddValues(worksheetPart.DrawingsPart.Parts.Select(p => p.RelationshipId), RelType.Workbook); + } var worksheetHasComments = worksheet.Internals.CellsCollection.GetCells(c => c.HasComment).Any(); @@ -315,7 +341,7 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) if (vmlDrawingPart == null) { - if (String.IsNullOrWhiteSpace(worksheet.LegacyDrawingId)) + if (string.IsNullOrWhiteSpace(worksheet.LegacyDrawingId)) { worksheet.LegacyDrawingId = context.RelIdGenerator.GetNext(RelType.Workbook); worksheet.LegacyDrawingIsNew = true; @@ -330,10 +356,14 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) // Remove empty parts if (commentsPart != null && (commentsPart.RootElement?.ChildElements?.Count ?? 0) == 0) + { worksheetPart.DeletePart(commentsPart); + } if (!hasAnyVmlElements && vmlDrawingPart != null) + { worksheetPart.DeletePart(vmlDrawingPart); + } GenerateWorksheetPartContent(worksheetPart, worksheet, options, context); @@ -344,20 +374,30 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) // Remove any orphaned references - maybe more types? foreach (var orphan in worksheetPart.Worksheet.OfType().Where(lg => worksheetPart.Parts.All(p => p.RelationshipId != lg.Id))) + { worksheetPart.Worksheet.RemoveChild(orphan); + } foreach (var orphan in worksheetPart.Worksheet.OfType().Where(d => worksheetPart.Parts.All(p => p.RelationshipId != d.Id))) + { worksheetPart.Worksheet.RemoveChild(orphan); + } } // Remove empty pivot cache part if (workbookPart.Workbook.PivotCaches != null && !workbookPart.Workbook.PivotCaches.Any()) + { workbookPart.Workbook.RemoveChild(workbookPart.Workbook.PivotCaches); + } if (options.GenerateCalculationChain) + { GenerateCalculationChainPartContent(workbookPart, context); + } else + { DeleteCalculationChainPartContent(workbookPart, context); + } if (workbookPart.ThemePart == null) { @@ -376,14 +416,16 @@ private void CreateParts(SpreadsheetDocument document, SaveOptions options) else { if (document.CustomFilePropertiesPart != null) + { document.DeletePart(document.CustomFilePropertiesPart); + } } SetPackageProperties(document); // Clear list of deleted worksheets to prevent errors on multiple saves worksheets.Deleted.Clear(); - this.ResumeEvents(); + ResumeEvents(); } private bool DeleteExistingComments(WorksheetPart worksheetPart, XLWorksheet worksheet, WorksheetCommentsPart commentsPart, VmlDrawingPart vmlDrawingPart) @@ -395,37 +437,39 @@ private bool DeleteExistingComments(WorksheetPart worksheetPart, XLWorksheet wor } if (vmlDrawingPart == null) + { return false; + } // Nuke the VmlDrawingPart elements for comments. - using (var vmlStream = vmlDrawingPart.GetStream(FileMode.Open)) + using var vmlStream = vmlDrawingPart.GetStream(FileMode.Open); + var xdoc = XDocumentExtensions.Load(vmlStream); + if (xdoc == null) { - var xdoc = XDocumentExtensions.Load(vmlStream); - if (xdoc == null) - return false; - - // Remove existing shapes for comments - xdoc.Root - .Elements() - .Where(e => e.Name.LocalName == "shapetype" && e.Attribute("id").Value == XLConstants.Comment.ShapeTypeId) - .Remove(); + return false; + } - xdoc.Root - .Elements() - .Where(e => e.Name.LocalName == "shape" && e.Attribute("type").Value == "#" + XLConstants.Comment.ShapeTypeId) - .Remove(); + // Remove existing shapes for comments + xdoc.Root + .Elements() + .Where(e => e.Name.LocalName == "shapetype" && e.Attribute("id").Value == XLConstants.Comment.ShapeTypeId) + .Remove(); - vmlStream.Position = 0; + xdoc.Root + .Elements() + .Where(e => e.Name.LocalName == "shape" && e.Attribute("type").Value == "#" + XLConstants.Comment.ShapeTypeId) + .Remove(); - using (var writer = new XmlTextWriter(vmlStream, Encoding.UTF8)) - { - var contents = xdoc.ToString(); - writer.WriteRaw(contents); - vmlStream.SetLength(contents.Length); - } + vmlStream.Position = 0; - return xdoc.Root.HasElements; + using (var writer = new XmlTextWriter(vmlStream, Encoding.UTF8)) + { + var contents = xdoc.ToString(); + writer.WriteRaw(contents); + vmlStream.SetLength(contents.Length); } + + return xdoc.Root.HasElements; } private static void GenerateTables(XLWorksheet worksheet, WorksheetPart worksheetPart, SaveContext context, XLWorksheetContentManager cm) @@ -434,7 +478,9 @@ private static void GenerateTables(XLWorksheet worksheet, WorksheetPart workshee var emptyTable = tables.FirstOrDefault(t => t.DataRange == null); if (emptyTable != null) + { throw new EmptyTableException($"Table '{emptyTable.Name}' should have at least 1 row."); + } TableParts tableParts; if (worksheetPart.Worksheet.Elements().Any()) @@ -465,16 +511,22 @@ private static void GenerateTables(XLWorksheet worksheet, WorksheetPart workshee foreach (var xlTable in tables.Cast()) { - if (String.IsNullOrEmpty(xlTable.RelId)) + if (string.IsNullOrEmpty(xlTable.RelId)) + { xlTable.RelId = context.RelIdGenerator.GetNext(RelType.Workbook); + } var relId = xlTable.RelId; TableDefinitionPart tableDefinitionPart; if (worksheetPart.HasPartWithId(relId)) + { tableDefinitionPart = worksheetPart.GetPartById(relId) as TableDefinitionPart; + } else + { tableDefinitionPart = worksheetPart.AddNewPart(relId); + } GenerateTableDefinitionPartContent(tableDefinitionPart, xlTable, context); @@ -485,13 +537,15 @@ private static void GenerateTables(XLWorksheet worksheet, WorksheetPart workshee } } - tableParts.Count = (UInt32)tables.Count(); + tableParts.Count = (uint)tables.Count(); } private void GenerateExtendedFilePropertiesPartContent(ExtendedFilePropertiesPart extendedFilePropertiesPart) { if (extendedFilePropertiesPart.Properties == null) - extendedFilePropertiesPart.Properties = new Properties(); + { + extendedFilePropertiesPart.Properties = new DocumentFormat.OpenXml.ExtendedProperties.Properties(); + } var properties = extendedFilePropertiesPart.Properties; if ( @@ -503,19 +557,29 @@ private void GenerateExtendedFilePropertiesPartContent(ExtendedFilePropertiesPar } if (properties.Application == null) + { properties.AppendChild(new Application { Text = "Microsoft Excel" }); + } if (properties.DocumentSecurity == null) + { properties.AppendChild(new DocumentSecurity { Text = "0" }); + } if (properties.ScaleCrop == null) + { properties.AppendChild(new ScaleCrop { Text = "false" }); + } if (properties.HeadingPairs == null) + { properties.HeadingPairs = new HeadingPairs(); + } if (properties.TitlesOfParts == null) + { properties.TitlesOfParts = new TitlesOfParts(); + } properties.HeadingPairs.VTVector = new VTVector { BaseType = VectorBaseValues.Variant }; @@ -534,42 +598,57 @@ private void GenerateExtendedFilePropertiesPartContent(ExtendedFilePropertiesPar InsertOnVtVector(vTVectorOne, "Worksheets", 0, modifiedWorksheetsCount.ToInvariantString()); InsertOnVtVector(vTVectorOne, "Named Ranges", 2, modifiedNamedRangesCount.ToInvariantString()); - vTVectorTwo.Size = (UInt32)(modifiedNamedRangesCount + modifiedWorksheetsCount); + vTVectorTwo.Size = (uint)(modifiedNamedRangesCount + modifiedWorksheetsCount); foreach ( var vTlpstr3 in modifiedWorksheets.OrderBy(w => w.Order).Select(w => new VTLPSTR { Text = w.Name })) + { vTVectorTwo.AppendChild(vTlpstr3); + } foreach (var vTlpstr7 in modifiedNamedRanges.Select(nr => new VTLPSTR { Text = nr })) + { vTVectorTwo.AppendChild(vTlpstr7); + } if (Properties.Manager != null) { - if (!String.IsNullOrWhiteSpace(Properties.Manager)) + if (!string.IsNullOrWhiteSpace(Properties.Manager)) { if (properties.Manager == null) + { properties.Manager = new Manager(); + } properties.Manager.Text = Properties.Manager; } else + { properties.Manager = null; + } } - if (Properties.Company == null) return; + if (Properties.Company == null) + { + return; + } - if (!String.IsNullOrWhiteSpace(Properties.Company)) + if (!string.IsNullOrWhiteSpace(Properties.Company)) { if (properties.Company == null) + { properties.Company = new Company(); + } properties.Company.Text = Properties.Company; } else + { properties.Company = null; + } } - private static void InsertOnVtVector(VTVector vTVector, String property, Int32 index, String text) + private static void InsertOnVtVector(VTVector vTVector, string property, int index, string text) { var m = from e1 in vTVector.Elements() where e1.Elements().Any(e2 => e2.Text == property) @@ -577,7 +656,9 @@ where e1.Elements().Any(e2 => e2.Text == property) if (!m.Any()) { if (vTVector.Size == null) + { vTVector.Size = new UInt32Value(0U); + } vTVector.Size += 2U; var variant1 = new Variant(); @@ -605,7 +686,7 @@ where e1.Elements().Any(e2 => e2.Text == property) private List GetModifiedNamedRanges() { - var namedRanges = new List(); + var namedRanges = new List(); foreach (var w in WorksheetsInternal) { var wName = w.Name; @@ -620,7 +701,9 @@ private List GetModifiedNamedRanges() private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions options, SaveContext context) { if (workbookPart.Workbook == null) + { workbookPart.Workbook = new Workbook(); + } var workbook = workbookPart.Workbook; if ( @@ -634,41 +717,53 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions #region WorkbookProperties if (workbook.WorkbookProperties == null) + { workbook.WorkbookProperties = new WorkbookProperties(); + } if (workbook.WorkbookProperties.CodeName == null) + { workbook.WorkbookProperties.CodeName = "ThisWorkbook"; + } - workbook.WorkbookProperties.Date1904 = OpenXmlHelper.GetBooleanValue(this.Use1904DateSystem, false); + workbook.WorkbookProperties.Date1904 = OpenXmlHelper.GetBooleanValue(Use1904DateSystem, false); if (options.FilterPrivacy.HasValue) + { workbook.WorkbookProperties.FilterPrivacy = OpenXmlHelper.GetBooleanValue(options.FilterPrivacy.Value, false); + } #endregion WorkbookProperties #region FileSharing if (workbook.FileSharing == null) + { workbook.FileSharing = new FileSharing(); + } - workbook.FileSharing.ReadOnlyRecommended = OpenXmlHelper.GetBooleanValue(this.FileSharing.ReadOnlyRecommended, false); - workbook.FileSharing.UserName = String.IsNullOrWhiteSpace(this.FileSharing.UserName) ? null : StringValue.FromString(this.FileSharing.UserName); + workbook.FileSharing.ReadOnlyRecommended = OpenXmlHelper.GetBooleanValue(FileSharing.ReadOnlyRecommended, false); + workbook.FileSharing.UserName = string.IsNullOrWhiteSpace(FileSharing.UserName) ? null : StringValue.FromString(FileSharing.UserName); if (!workbook.FileSharing.HasChildren && !workbook.FileSharing.HasAttributes) + { workbook.FileSharing = null; + } #endregion FileSharing #region WorkbookProtection - if (this.Protection.IsProtected) + if (Protection.IsProtected) { if (workbook.WorkbookProtection == null) + { workbook.WorkbookProtection = new WorkbookProtection(); + } var workbookProtection = workbook.WorkbookProtection; - var protection = this.Protection; + var protection = Protection; workbookProtection.WorkbookPassword = null; workbookProtection.WorkbookAlgorithmName = null; @@ -678,8 +773,10 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions if (protection.Algorithm == XLProtectionAlgorithm.Algorithm.SimpleHash) { - if (!String.IsNullOrWhiteSpace(protection.PasswordHash)) + if (!string.IsNullOrWhiteSpace(protection.PasswordHash)) + { workbookProtection.WorkbookPassword = protection.PasswordHash; + } } else { @@ -700,10 +797,14 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions #endregion WorkbookProtection if (workbook.BookViews == null) + { workbook.BookViews = new BookViews(); + } if (workbook.Sheets == null) + { workbook.Sheets = new Sheets(); + } var worksheets = WorksheetsInternal; workbook.Sheets.Elements().Where(s => worksheets.Deleted.Contains(s.Id)).ToList().ForEach( @@ -711,9 +812,12 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions foreach (var sheet in workbook.Sheets.Elements()) { - var sheetId = (Int32)sheet.SheetId.Value; + var sheetId = (int)sheet.SheetId.Value; - if (WorksheetsInternal.All(w => w.SheetId != sheetId)) continue; + if (WorksheetsInternal.All(w => w.SheetId != sheetId)) + { + continue; + } var wks = WorksheetsInternal.Single(w => w.SheetId == sheetId); wks.RelId = sheet.Id; @@ -723,25 +827,29 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions foreach (var xlSheet in WorksheetsInternal.Cast().OrderBy(w => w.Position)) { string rId; - if (xlSheet.SheetId == 0 && String.IsNullOrWhiteSpace(xlSheet.RelId)) + if (xlSheet.SheetId == 0 && string.IsNullOrWhiteSpace(xlSheet.RelId)) { rId = context.RelIdGenerator.GetNext(RelType.Workbook); - while (WorksheetsInternal.Cast().Any(w => w.SheetId == Int32.Parse(rId.Substring(3)))) + while (WorksheetsInternal.Cast().Any(w => w.SheetId == int.Parse(rId.Substring(3)))) + { rId = context.RelIdGenerator.GetNext(RelType.Workbook); + } - xlSheet.SheetId = Int32.Parse(rId.Substring(3)); + xlSheet.SheetId = int.Parse(rId.Substring(3)); xlSheet.RelId = rId; } else { - if (String.IsNullOrWhiteSpace(xlSheet.RelId)) + if (string.IsNullOrWhiteSpace(xlSheet.RelId)) { - rId = String.Concat("rId", xlSheet.SheetId); - context.RelIdGenerator.AddValues(new List { rId }, RelType.Workbook); + rId = string.Concat("rId", xlSheet.SheetId); + context.RelIdGenerator.AddValues(new List { rId }, RelType.Workbook); } else + { rId = xlSheet.RelId; + } } if (workbook.Sheets.Cast().All(s => s.Id != rId)) @@ -750,7 +858,7 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions { Name = xlSheet.Name, Id = rId, - SheetId = (UInt32)xlSheet.SheetId + SheetId = (uint)xlSheet.SheetId }; workbook.Sheets.AppendChild(newSheet); @@ -758,14 +866,14 @@ private void GenerateWorkbookPartContent(WorkbookPart workbookPart, SaveOptions } var sheetElements = from sheet in workbook.Sheets.Elements() - join worksheet in ((IEnumerable)WorksheetsInternal) on sheet.Id.Value + join worksheet in (IEnumerable)WorksheetsInternal on sheet.Id.Value equals worksheet.RelId orderby worksheet.Position select sheet; - UInt32 firstSheetVisible = 0; + uint firstSheetVisible = 0; var activeTab = - (from us in UnsupportedSheets where us.IsActive select (UInt32)us.Position - 1).FirstOrDefault(); + (from us in UnsupportedSheets where us.IsActive select (uint)us.Position - 1).FirstOrDefault(); var foundVisible = false; var totalSheets = sheetElements.Count() + UnsupportedSheets.Count; @@ -778,16 +886,27 @@ orderby worksheet.Position workbook.Sheets.AppendChild(sheet); var xlSheet = Worksheet(sheet.Name); if (xlSheet.Visibility != XLWorksheetVisibility.Visible) + { sheet.State = xlSheet.Visibility.ToOpenXml(); + } else + { sheet.State = null; + } - if (foundVisible) continue; + if (foundVisible) + { + continue; + } if (sheet.State == null || sheet.State == SheetStateValues.Visible) + { foundVisible = true; + } else + { firstSheetVisible++; + } } else { @@ -802,19 +921,19 @@ orderby worksheet.Position if (activeTab == 0) { - UInt32? firstActiveTab = null; - UInt32? firstSelectedTab = null; + uint? firstActiveTab = null; + uint? firstSelectedTab = null; foreach (var ws in worksheets) { if (ws.TabActive) { - firstActiveTab = (UInt32)(ws.Position - 1); + firstActiveTab = (uint)(ws.Position - 1); break; } if (ws.TabSelected) { - firstSelectedTab = (UInt32)(ws.Position - 1); + firstSelectedTab = (uint)(ws.Position - 1); } } @@ -837,8 +956,8 @@ orderby worksheet.Position var definedNames = new DefinedNames(); foreach (var worksheet in WorksheetsInternal) { - var wsSheetId = (UInt32)worksheet.SheetId; - UInt32 sheetId = 0; + var wsSheetId = (uint)worksheet.SheetId; + uint sheetId = 0; foreach (var s in workbook.Sheets.Elements().TakeWhile(s => s.SheetId != wsSheetId)) { sheetId++; @@ -848,10 +967,10 @@ orderby worksheet.Position { var definedName = new DefinedName { Name = "_xlnm.Print_Area", LocalSheetId = sheetId }; var worksheetName = worksheet.Name; - var definedNameText = worksheet.PageSetup.PrintAreas.Aggregate(String.Empty, + var definedNameText = worksheet.PageSetup.PrintAreas.Aggregate(string.Empty, (current, printArea) => current + - (worksheetName.EscapeSheetName() + "!" + + worksheetName.EscapeSheetName() + "!" + printArea.RangeAddress. FirstAddress.ToStringFixed( XLReferenceStyle.A1) + @@ -859,7 +978,7 @@ orderby worksheet.Position printArea.RangeAddress. LastAddress.ToStringFixed( XLReferenceStyle.A1) + - ",")); + ","); definedName.Text = definedNameText.Substring(0, definedNameText.Length - 1); definedNames.AppendChild(definedName); } @@ -891,15 +1010,20 @@ orderby worksheet.Position }; if (!nr.Visible) + { definedName.Hidden = BooleanValue.FromBoolean(true); + } - if (!String.IsNullOrWhiteSpace(nr.Comment)) + if (!string.IsNullOrWhiteSpace(nr.Comment)) + { definedName.Comment = nr.Comment; + } + definedNames.AppendChild(definedName); } - var definedNameTextRow = String.Empty; - var definedNameTextColumn = String.Empty; + var definedNameTextRow = string.Empty; + var definedNameTextColumn = string.Empty; if (worksheet.PageSetup.FirstRowToRepeatAtTop > 0) { definedNameTextRow = worksheet.Name.EscapeSheetName() + "!" + worksheet.PageSetup.FirstRowToRepeatAtTop @@ -919,12 +1043,19 @@ orderby worksheet.Position { titles = definedNameTextColumn; if (definedNameTextRow.Length > 0) + { titles += "," + definedNameTextRow; + } } else + { titles = definedNameTextRow; + } - if (titles.Length <= 0) continue; + if (titles.Length <= 0) + { + continue; + } var definedName2 = new DefinedName { @@ -948,32 +1079,62 @@ orderby worksheet.Position }; if (!nr.Visible) + { definedName.Hidden = BooleanValue.FromBoolean(true); + } - if (!String.IsNullOrWhiteSpace(nr.Comment)) + if (!string.IsNullOrWhiteSpace(nr.Comment)) + { definedName.Comment = nr.Comment; + } + definedNames.AppendChild(definedName); } workbook.DefinedNames = definedNames; if (workbook.CalculationProperties == null) + { workbook.CalculationProperties = new CalculationProperties { CalculationId = 125725U }; + } if (CalculateMode == XLCalculateMode.Default) + { workbook.CalculationProperties.CalculationMode = null; + } else + { workbook.CalculationProperties.CalculationMode = CalculateMode.ToOpenXml(); + } if (ReferenceStyle == XLReferenceStyle.Default) + { workbook.CalculationProperties.ReferenceMode = null; + } else + { workbook.CalculationProperties.ReferenceMode = ReferenceStyle.ToOpenXml(); + } + + if (CalculationOnSave) + { + workbook.CalculationProperties.CalculationOnSave = CalculationOnSave; + } + + if (ForceFullCalculation) + { + workbook.CalculationProperties.ForceFullCalculation = ForceFullCalculation; + } + + if (FullCalculationOnLoad) + { + workbook.CalculationProperties.FullCalculationOnLoad = FullCalculationOnLoad; + } - if (CalculationOnSave) workbook.CalculationProperties.CalculationOnSave = CalculationOnSave; - if (ForceFullCalculation) workbook.CalculationProperties.ForceFullCalculation = ForceFullCalculation; - if (FullCalculationOnLoad) workbook.CalculationProperties.FullCalculationOnLoad = FullCalculationOnLoad; - if (FullPrecision) workbook.CalculationProperties.FullPrecision = FullPrecision; + if (FullPrecision) + { + workbook.CalculationProperties.FullPrecision = FullPrecision; + } } private void GenerateSharedStringTablePartContent(SharedStringTablePart sharedStringTablePart, @@ -987,15 +1148,19 @@ private void GenerateSharedStringTablePartContent(SharedStringTablePart sharedSt var stringId = 0; - var newStrings = new Dictionary(); - var newRichStrings = new Dictionary(); + var newStrings = new Dictionary(); + var newRichStrings = new Dictionary(); - bool hasSharedString(IXLCell c) + static bool hasSharedString(IXLCell c) { if (c.DataType == XLDataType.Text && c.ShareString) - return (c as XLCell).StyleValue.IncludeQuotePrefix || String.IsNullOrWhiteSpace(c.FormulaA1) && (c as XLCell).InnerText.Length > 0; + { + return (c as XLCell).StyleValue.IncludeQuotePrefix || string.IsNullOrWhiteSpace(c.FormulaA1) && (c as XLCell).InnerText.Length > 0; + } else + { return false; + } } foreach (var c in Worksheets.Cast().SelectMany(w => w.Internals.CellsCollection.GetCells(hasSharedString))) @@ -1003,8 +1168,10 @@ bool hasSharedString(IXLCell c) c.DataType = XLDataType.Text; if (c.HasRichText) { - if (newRichStrings.TryGetValue(c.GetRichText(), out int id)) + if (newRichStrings.TryGetValue(c.GetRichText(), out var id)) + { c.SharedStringId = id; + } else { var sharedStringItem = new SharedStringItem(); @@ -1023,15 +1190,20 @@ bool hasSharedString(IXLCell c) else { var value = c.Value.ObjectToInvariantString(); - if (newStrings.TryGetValue(value, out int id)) + if (newStrings.TryGetValue(value, out var id)) + { c.SharedStringId = id; + } else { var s = value; var sharedStringItem = new SharedStringItem(); var text = new Text { Text = XmlEncoder.EncodeString(s) }; if (!s.Trim().Equals(s)) + { text.Space = SpaceProcessingModeValues.Preserve; + } + sharedStringItem.Append(text); sharedStringTablePart.SharedStringTable.Append(sharedStringItem); sharedStringTablePart.SharedStringTable.Count += 1; @@ -1049,7 +1221,7 @@ bool hasSharedString(IXLCell c) private static void PopulatedRichTextElements(RstType rstType, IXLCell cell, SaveContext context) { var richText = cell.GetRichText(); - foreach (var rt in richText.Where(r => !String.IsNullOrEmpty(r.Text))) + foreach (var rt in richText.Where(r => !string.IsNullOrEmpty(r.Text))) { rstType.Append(GetRun(rt)); } @@ -1060,13 +1232,15 @@ private static void PopulatedRichTextElements(RstType rstType, IXLCell cell, Sav { var phoneticRun = new PhoneticRun { - BaseTextStartIndex = (UInt32)p.Start, - EndingBaseIndex = (UInt32)p.End + BaseTextStartIndex = (uint)p.Start, + EndingBaseIndex = (uint)p.End }; var text = new Text { Text = p.Text }; if (p.Text.PreserveSpaces()) + { text.Space = SpaceProcessingModeValues.Preserve; + } phoneticRun.Append(text); rstType.Append(phoneticRun); @@ -1075,7 +1249,7 @@ private static void PopulatedRichTextElements(RstType rstType, IXLCell cell, Sav var fontKey = XLFont.GenerateKey(richText.Phonetics); var f = XLFontValue.FromKey(ref fontKey); - if (!context.SharedFonts.TryGetValue(f, out FontInfo fi)) + if (!context.SharedFonts.TryGetValue(f, out var fi)) { fi = new FontInfo { Font = f }; context.SharedFonts.Add(f, fi); @@ -1087,10 +1261,14 @@ private static void PopulatedRichTextElements(RstType rstType, IXLCell cell, Sav }; if (richText.Phonetics.Alignment != XLPhoneticAlignment.Left) + { phoneticProperties.Alignment = richText.Phonetics.Alignment.ToOpenXml(); + } if (richText.Phonetics.Type != XLPhoneticType.FullWidthKatakana) + { phoneticProperties.Type = richText.Phonetics.Type.ToOpenXml(); + } rstType.Append(phoneticProperties); } @@ -1114,14 +1292,33 @@ private static Run GetRun(IXLRichString rt) var fontSize = new FontSize { Val = rt.FontSize }; var color = new Color().FromClosedXMLColor(rt.FontColor); var fontName = new RunFont { Val = rt.FontName }; - var fontFamilyNumbering = new FontFamily { Val = (Int32)rt.FontFamilyNumbering }; + var fontFamilyNumbering = new FontFamily { Val = (int)rt.FontFamilyNumbering }; + + if (bold != null) + { + runProperties.Append(bold); + } + + if (italic != null) + { + runProperties.Append(italic); + } + + if (strike != null) + { + runProperties.Append(strike); + } + + if (shadow != null) + { + runProperties.Append(shadow); + } - if (bold != null) runProperties.Append(bold); - if (italic != null) runProperties.Append(italic); + if (underline != null) + { + runProperties.Append(underline); + } - if (strike != null) runProperties.Append(strike); - if (shadow != null) runProperties.Append(shadow); - if (underline != null) runProperties.Append(underline); runProperties.Append(verticalAlignment); runProperties.Append(fontSize); @@ -1131,7 +1328,9 @@ private static Run GetRun(IXLRichString rt) var text = new Text { Text = rt.Text }; if (rt.Text.PreserveSpaces()) + { text.Space = SpaceProcessingModeValues.Preserve; + } run.Append(runProperties); run.Append(text); @@ -1141,16 +1340,22 @@ private static Run GetRun(IXLRichString rt) private void DeleteCalculationChainPartContent(WorkbookPart workbookPart, SaveContext context) { if (workbookPart.CalculationChainPart != null) + { workbookPart.DeletePart(workbookPart.CalculationChainPart); + } } private void GenerateCalculationChainPartContent(WorkbookPart workbookPart, SaveContext context) { if (workbookPart.CalculationChainPart == null) + { workbookPart.AddNewPart(context.RelIdGenerator.GetNext(RelType.Workbook)); + } if (workbookPart.CalculationChainPart.CalculationChain == null) + { workbookPart.CalculationChainPart.CalculationChain = new CalculationChain(); + } var calculationChain = workbookPart.CalculationChainPart.CalculationChain; calculationChain.RemoveAllChildren(); @@ -1162,7 +1367,9 @@ private void GenerateCalculationChainPartContent(WorkbookPart workbookPart, Save if (c.HasArrayFormula) { if (c.FormulaReference == null) + { c.FormulaReference = c.AsRange().RangeAddress; + } if (c.FormulaReference.FirstAddress.Equals(c.Address)) { @@ -1200,7 +1407,9 @@ private void GenerateCalculationChainPartContent(WorkbookPart workbookPart, Save } if (!calculationChain.Any()) + { workbookPart.DeletePart(workbookPart.CalculationChainPart); + } } private void GenerateThemePartContent(ThemePart themePart) @@ -1846,13 +2055,13 @@ private void GenerateCustomFilePropertiesPartContent(CustomFilePropertiesPart cu { var vTDouble1 = new VTDouble { - Text = p.GetValue().ToInvariantString() + Text = p.GetValue().ToInvariantString() }; customDocumentProperty.AppendChild(vTDouble1); } else { - var vTBool1 = new VTBool { Text = p.GetValue().ToString().ToLower() }; + var vTBool1 = new VTBool { Text = p.GetValue().ToString().ToLower() }; customDocumentProperty.AppendChild(vTBool1); } properties.AppendChild(customDocumentProperty); @@ -1870,14 +2079,45 @@ private void SetPackageProperties(OpenXmlPackage document) #if true // Workaround: https://github.com/OfficeDev/Open-XML-SDK/issues/235 - if (Properties.LastModifiedBy == null) document.PackageProperties.LastModifiedBy = ""; - if (Properties.Author == null) document.PackageProperties.Creator = ""; - if (Properties.Title == null) document.PackageProperties.Title = ""; - if (Properties.Subject == null) document.PackageProperties.Subject = ""; - if (Properties.Category == null) document.PackageProperties.Category = ""; - if (Properties.Keywords == null) document.PackageProperties.Keywords = ""; - if (Properties.Comments == null) document.PackageProperties.Description = ""; - if (Properties.Status == null) document.PackageProperties.ContentStatus = ""; + if (Properties.LastModifiedBy == null) + { + document.PackageProperties.LastModifiedBy = ""; + } + + if (Properties.Author == null) + { + document.PackageProperties.Creator = ""; + } + + if (Properties.Title == null) + { + document.PackageProperties.Title = ""; + } + + if (Properties.Subject == null) + { + document.PackageProperties.Subject = ""; + } + + if (Properties.Category == null) + { + document.PackageProperties.Category = ""; + } + + if (Properties.Keywords == null) + { + document.PackageProperties.Keywords = ""; + } + + if (Properties.Comments == null) + { + document.PackageProperties.Description = ""; + } + + if (Properties.Status == null) + { + document.PackageProperties.ContentStatus = ""; + } #endif @@ -1892,7 +2132,7 @@ private void SetPackageProperties(OpenXmlPackage document) document.PackageProperties.ContentStatus = Properties.Status; } - private static string GetTableName(String originalTableName, SaveContext context) + private static string GetTableName(string originalTableName, SaveContext context) { var tableName = originalTableName.RemoveSpecialCharacters(); var name = tableName; @@ -1925,16 +2165,22 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table }; if (!xlTable.ShowHeaderRow) + { table.HeaderRowCount = 0; + } if (xlTable.ShowTotalsRow) + { table.TotalsRowCount = 1; + } else + { table.TotalsRowShown = false; + } - var tableColumns = new TableColumns { Count = (UInt32)xlTable.ColumnCount() }; + var tableColumns = new TableColumns { Count = (uint)xlTable.ColumnCount() }; - UInt32 columnId = 0; + uint columnId = 0; foreach (var xlField in xlTable.Fields) { columnId++; @@ -1942,7 +2188,7 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table var tableColumn = new TableColumn { Id = columnId, - Name = fieldName.Replace("_x000a_", "_x005f_x000a_").Replace(Environment.NewLine, "_x000a_") + Name = fieldName.Replace("_x000a_", "_x005f_x000a_").Replace(XLConstants.NewLine, "_x000a_") }; // https://github.com/ClosedXML/ClosedXML/issues/513 @@ -1953,23 +2199,29 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table .First() .Style as XLStyle).Value; - if (!DefaultStyleValue.Equals(style) && context.DifferentialFormats.TryGetValue(style, out Int32 id)) + if (!DefaultStyleValue.Equals(style) && context.DifferentialFormats.TryGetValue(style, out var id)) + { tableColumn.DataFormatId = UInt32Value.FromUInt32(Convert.ToUInt32(id)); + } } else + { tableColumn.DataFormatId = null; + } if (xlField.IsConsistentFormula()) { - string formula = xlField.Column.Cells() + var formula = xlField.Column.Cells() .Skip(xlTable.ShowHeaderRow ? 1 : 0) .First() .FormulaA1; while (formula.StartsWith("=") && formula.Length > 1) + { formula = formula.Substring(1); + } - if (!String.IsNullOrWhiteSpace(formula)) + if (!string.IsNullOrWhiteSpace(formula)) { tableColumn.CalculatedColumnFormula = new CalculatedColumnFormula { @@ -1978,7 +2230,9 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table } } else + { tableColumn.CalculatedColumnFormula = null; + } if (xlTable.ShowTotalsRow) { @@ -1987,11 +2241,15 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table tableColumn.TotalsRowFunction = xlField.TotalsRowFunction.ToOpenXml(); if (xlField.TotalsRowFunction == XLTotalsRowFunction.Custom) + { tableColumn.TotalsRowFormula = new TotalsRowFormula(xlField.TotalsRowFormulaA1); + } } - if (!String.IsNullOrWhiteSpace(xlField.TotalsRowLabel)) + if (!string.IsNullOrWhiteSpace(xlField.TotalsRowLabel)) + { tableColumn.TotalsRowLabel = xlField.TotalsRowLabel; + } } tableColumns.AppendChild(tableColumn); } @@ -2005,7 +2263,9 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table }; if (xlTable.Theme != XLTableTheme.None) + { tableStyleInfo1.Name = xlTable.Theme.Name; + } if (xlTable.ShowAutoFilter) { @@ -2017,7 +2277,9 @@ private static void GenerateTableDefinitionPartContent(TableDefinitionPart table xlTable.RangeAddress.LastAddress.RowNumber - 1, xlTable.RangeAddress.LastAddress.ColumnNumber); } else + { xlTable.AutoFilter.Range = xlTable.Worksheet.Range(xlTable.RangeAddress); + } PopulateAutoFilter(xlTable.AutoFilter, autoFilter1); @@ -2037,12 +2299,16 @@ private static void GeneratePivotTables(WorkbookPart workbookPart, WorksheetPart PivotCaches pivotCaches; uint cacheId = 0; if (workbookPart.Workbook.PivotCaches == null) + { pivotCaches = workbookPart.Workbook.InsertAfter(new PivotCaches(), workbookPart.Workbook.CalculationProperties); + } else { pivotCaches = workbookPart.Workbook.PivotCaches; if (pivotCaches.Any()) + { cacheId = pivotCaches.Cast().Max(pc => pc.CacheId.Value) + 1; + } } foreach (var pt in xlWorksheet.PivotTables.Cast()) @@ -2053,7 +2319,7 @@ private static void GeneratePivotTables(WorkbookPart workbookPart, WorksheetPart PivotCache pivotCache; PivotTableCacheDefinitionPart pivotTableCacheDefinitionPart; - if (!String.IsNullOrWhiteSpace(pt.WorkbookCacheRelId)) + if (!string.IsNullOrWhiteSpace(pt.WorkbookCacheRelId)) { pivotCache = pivotCaches.Cast().Single(pc => pc.Id.Value == pt.WorkbookCacheRelId); pivotTableCacheDefinitionPart = workbookPart.GetPartById(pt.WorkbookCacheRelId) as PivotTableCacheDefinitionPart; @@ -2070,7 +2336,7 @@ private static void GeneratePivotTables(WorkbookPart workbookPart, WorksheetPart GeneratePivotTableCacheDefinitionPartContent(pivotTableCacheDefinitionPart, pt, context); PivotTablePart pivotTablePart; - var createNewPivotTablePart = String.IsNullOrWhiteSpace(pt.RelId); + var createNewPivotTablePart = string.IsNullOrWhiteSpace(pt.RelId); if (createNewPivotTablePart) { var relId = context.RelIdGenerator.GetNext(RelType.Workbook); @@ -2078,12 +2344,16 @@ private static void GeneratePivotTables(WorkbookPart workbookPart, WorksheetPart pivotTablePart = worksheetPart.AddNewPart(relId); } else + { pivotTablePart = worksheetPart.GetPartById(pt.RelId) as PivotTablePart; + } GeneratePivotTablePartContent(pivotTablePart, pt, pivotCache.CacheId, context); if (createNewPivotTablePart) + { pivotTablePart.AddPart(pivotTableCacheDefinitionPart, context.RelIdGenerator.GetNext(RelType.Workbook)); + } } } @@ -2103,22 +2373,30 @@ private static void GeneratePivotTableCacheDefinitionPartContent( #region CreatedVersion - byte createdVersion = XLConstants.PivotTable.CreatedVersion; + var createdVersion = XLConstants.PivotTable.CreatedVersion; if (pivotCacheDefinition.CreatedVersion?.HasValue ?? false) + { pivotCacheDefinition.CreatedVersion = Math.Max(createdVersion, pivotCacheDefinition.CreatedVersion.Value); + } else + { pivotCacheDefinition.CreatedVersion = createdVersion; + } #endregion CreatedVersion #region RefreshedVersion - byte refreshedVersion = XLConstants.PivotTable.RefreshedVersion; + var refreshedVersion = XLConstants.PivotTable.RefreshedVersion; if (pivotCacheDefinition.RefreshedVersion?.HasValue ?? false) + { pivotCacheDefinition.RefreshedVersion = Math.Max(refreshedVersion, pivotCacheDefinition.RefreshedVersion.Value); + } else + { pivotCacheDefinition.RefreshedVersion = refreshedVersion; + } #endregion RefreshedVersion @@ -2126,9 +2404,13 @@ private static void GeneratePivotTableCacheDefinitionPartContent( byte minRefreshableVersion = 3; if (pivotCacheDefinition.MinRefreshableVersion?.HasValue ?? false) + { pivotCacheDefinition.MinRefreshableVersion = Math.Max(minRefreshableVersion, pivotCacheDefinition.MinRefreshableVersion.Value); + } else + { pivotCacheDefinition.MinRefreshableVersion = minRefreshableVersion; + } #endregion MinRefreshableVersion @@ -2138,14 +2420,18 @@ private static void GeneratePivotTableCacheDefinitionPartContent( var pti = new PivotTableInfo { Guid = pt.Guid, - Fields = new Dictionary() + Fields = new Dictionary() }; var source = pt.SourceRange; if (pt.ItemsToRetainPerField == XLItemsToRetain.None) + { pivotCacheDefinition.MissingItemsLimit = 0U; + } else if (pt.ItemsToRetainPerField == XLItemsToRetain.Max) + { pivotCacheDefinition.MissingItemsLimit = XLHelper.MaxRowNumber; + } // Begin CacheSource var cacheSource = new CacheSource { Type = SourceValues.Worksheet }; @@ -2216,9 +2502,13 @@ private static void GeneratePivotTableCacheDefinitionPartContent( XLPivotField xlpf; if (pt.Fields.Contains(columnName)) + { xlpf = pt.Fields.Get(columnName) as XLPivotField; + } else + { xlpf = pt.Fields.Add(columnName) as XLPivotField; + } var field = pt.RowLabels .Union(pt.ColumnLabels) @@ -2274,8 +2564,8 @@ private static void GeneratePivotTableCacheDefinitionPartContent( ptfi.DataType = XLDataType.Number; ptfi.MixedDataType = false; ptfi.DistinctValues = fieldValueCells - .Where(cell => cell.TryGetValue(out Double _)) - .Select(cell => cell.CachedValue.CastTo()) + .Where(cell => cell.TryGetValue(out double _)) + .Select(cell => cell.CachedValue.CastTo()) .Distinct() .Cast() .ToArray(); @@ -2301,17 +2591,21 @@ private static void GeneratePivotTableCacheDefinitionPartContent( ptfi.MixedDataType = types.Length > 1; if (!ptfi.MixedDataType && ptfi.DataType == XLDataType.Text) + { ptfi.DistinctValues = fieldValueCells - .Where(cell => cell.TryGetValue(out String _)) - .Select(cell => cell.CachedValue.CastTo()) + .Where(cell => cell.TryGetValue(out string _)) + .Select(cell => cell.CachedValue.CastTo()) .Distinct(StringComparer.OrdinalIgnoreCase) .ToArray(); + } else + { ptfi.DistinctValues = fieldValueCells - .Where(cell => cell.TryGetValue(out String _)) + .Where(cell => cell.TryGetValue(out string _)) .Select(cell => cell.GetString()) .Distinct(StringComparer.OrdinalIgnoreCase) .ToArray(); + } pti.Fields.Add(xlpf.SourceName, ptfi); } @@ -2319,7 +2613,9 @@ private static void GeneratePivotTableCacheDefinitionPartContent( // If this cache field exists and contains shared items, // then we can assume that this as been populated by a previous pivot table if (sharedItems.Any()) + { continue; + } // Else we have to populate the items if (types.Length == 1 && types.Single() == XLDataType.Number) @@ -2328,8 +2624,11 @@ private static void GeneratePivotTableCacheDefinitionPartContent( sharedItems.ContainsString = false; sharedItems.ContainsNumber = true; - var allInteger = ptfi.DistinctValues.All(v => int.TryParse(v.ToString(), out int val)); - if (allInteger) sharedItems.ContainsInteger = true; + var allInteger = ptfi.DistinctValues.All(v => int.TryParse(v.ToString(), out var val)); + if (allInteger) + { + sharedItems.ContainsInteger = true; + } // Output items only for row / column / filter fields if (pt.RowLabels.Any(p => p.SourceName == xlpf.SourceName) @@ -2337,9 +2636,14 @@ private static void GeneratePivotTableCacheDefinitionPartContent( || pt.ReportFilters.Any(p => p.SourceName == xlpf.SourceName)) { foreach (var value in ptfi.DistinctValues) + { sharedItems.AppendChild(new NumberItem { Val = (double)value }); + } - if (containsBlank) sharedItems.AppendChild(new MissingItem()); + if (containsBlank) + { + sharedItems.AppendChild(new MissingItem()); + } } sharedItems.MinValue = (double)ptfi.DistinctValues.Min(); @@ -2358,9 +2662,14 @@ private static void GeneratePivotTableCacheDefinitionPartContent( || pt.ReportFilters.Any(p => p.SourceName == xlpf.SourceName)) { foreach (var value in ptfi.DistinctValues) + { sharedItems.AppendChild(new DateTimeItem { Val = (DateTime)value }); + } - if (containsBlank) sharedItems.AppendChild(new MissingItem()); + if (containsBlank) + { + sharedItems.AppendChild(new MissingItem()); + } } sharedItems.MinDate = (DateTime)ptfi.DistinctValues.Min(); @@ -2369,23 +2678,37 @@ private static void GeneratePivotTableCacheDefinitionPartContent( else { if (ptfi.DistinctValues.Any(v => ((string)v).Length > 255)) + { sharedItems.LongText = true; + } foreach (var value in ptfi.DistinctValues) + { sharedItems.AppendChild(new StringItem { Val = (string)value }); + } - if (containsBlank) sharedItems.AppendChild(new MissingItem()); + if (containsBlank) + { + sharedItems.AppendChild(new MissingItem()); + } } sharedItems.Count = Convert.ToUInt32(sharedItems.Elements().Count()); } - if (containsBlank) sharedItems.ContainsBlank = true; + if (containsBlank) + { + sharedItems.ContainsBlank = true; + } if (ptfi.IsTotallyBlankField) + { pti.Fields.Add(xlpf.SourceName, ptfi); + } else if (ptfi.DistinctValues?.Any() ?? false) + { sharedItems.Count = Convert.ToUInt32(ptfi.DistinctValues.Count()); + } } // End CacheFields @@ -2407,18 +2730,17 @@ private static void GeneratePivotTablePartContent( PivotTablePart pivotTablePart, XLPivotTable pt, uint cacheId, SaveContext context) { - var pti = context.PivotTables[(pt as XLPivotTable).Guid]; + var pti = context.PivotTables[pt.Guid]; var pivotTableDefinition = new PivotTableDefinition { Name = pt.Name, CacheId = cacheId, - DataCaption = "Values", MergeItem = OpenXmlHelper.GetBooleanValue(pt.MergeAndCenterWithLabels, false), Indent = Convert.ToUInt32(pt.RowLabelIndent), - PageOverThenDown = (pt.FilterAreaOrder == XLFilterAreaOrder.OverThenDown), + PageOverThenDown = pt.FilterAreaOrder == XLFilterAreaOrder.OverThenDown, PageWrap = Convert.ToUInt32(pt.FilterFieldsPageWrap), - ShowError = String.IsNullOrEmpty(pt.ErrorValueReplacement), + ShowError = string.IsNullOrEmpty(pt.ErrorValueReplacement), UseAutoFormatting = OpenXmlHelper.GetBooleanValue(pt.AutofitColumns, false), PreserveFormatting = OpenXmlHelper.GetBooleanValue(pt.PreserveCellFormatting, true), RowGrandTotals = OpenXmlHelper.GetBooleanValue(pt.ShowGrandTotalsRows, true), @@ -2441,11 +2763,29 @@ private static void GeneratePivotTablePartContent( EnableDrill = OpenXmlHelper.GetBooleanValue(pt.EnableShowDetails, true) }; - if (!String.IsNullOrEmpty(pt.ColumnHeaderCaption)) + if (!string.IsNullOrEmpty(pt.GrandTotalCaption)) + { + pivotTableDefinition.GrandTotalCaption = pt.GrandTotalCaption; + } + + if (!string.IsNullOrEmpty(pt.DataCaption)) + { + pivotTableDefinition.DataCaption = pt.DataCaption; + } + else + { + pivotTableDefinition.DataCaption = "Values"; + } + + if (!string.IsNullOrEmpty(pt.ColumnHeaderCaption)) + { pivotTableDefinition.ColumnHeaderCaption = StringValue.FromString(pt.ColumnHeaderCaption); + } - if (!String.IsNullOrEmpty(pt.RowHeaderCaption)) + if (!string.IsNullOrEmpty(pt.RowHeaderCaption)) + { pivotTableDefinition.RowHeaderCaption = StringValue.FromString(pt.RowHeaderCaption); + } if (pt.ClassicPivotTableLayout) { @@ -2486,7 +2826,9 @@ private static void GeneratePivotTablePartContent( location.Reference = pt.TargetCell.CellBelow(pt.ReportFilters.Count() + 1).Address.ToString(); } else + { location.Reference = pt.TargetCell.Address.ToString(); + } var rowFields = new RowFields(); var columnFields = new ColumnFields(); @@ -2527,7 +2869,9 @@ private static void GeneratePivotTablePartContent( orderedRowLabels.Add(rowLabelIndex, f); if (ptfi.IsTotallyBlankField) + { rowItems.AppendChild(new RowItem()); + } else { for (var i = 0; i < ptfi.DistinctValues.Count(); i++) @@ -2549,7 +2893,9 @@ private static void GeneratePivotTablePartContent( orderedColumnLabels.Add(columnlabelIndex, f); if (ptfi.IsTotallyBlankField) + { columnItems.AppendChild(new RowItem()); + } else { for (var i = 0; i < ptfi.DistinctValues.Count(); i++) @@ -2654,7 +3000,9 @@ private static void GeneratePivotTablePartContent( .ToList(); var selectedValue = labelOrFilterField.SelectedValues.Single().ObjectToInvariantString().ToLower(); if (values.Contains(selectedValue)) + { pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue)); + } } else if (ptfi.DataType == XLDataType.DateTime) { @@ -2663,7 +3011,9 @@ private static void GeneratePivotTablePartContent( .ToList(); var selectedValue = Convert.ToDateTime(labelOrFilterField.SelectedValues.Single()); if (values.Contains(selectedValue)) + { pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue)); + } } else if (ptfi.DataType == XLDataType.Number) { @@ -2672,7 +3022,9 @@ private static void GeneratePivotTablePartContent( .ToList(); var selectedValue = Convert.ToDouble(labelOrFilterField.SelectedValues.Single()); if (values.Contains(selectedValue)) + { pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue)); + } } else if (ptfi.DataType == XLDataType.Boolean) { @@ -2681,7 +3033,9 @@ private static void GeneratePivotTablePartContent( .ToList(); var selectedValue = Convert.ToBoolean(labelOrFilterField.SelectedValues.Single()); if (values.Contains(selectedValue)) + { pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue)); + } } else if (ptfi.DataType == XLDataType.TimeSpan) { @@ -2690,20 +3044,28 @@ private static void GeneratePivotTablePartContent( .ToList(); var selectedValue = (TimeSpan)labelOrFilterField.SelectedValues.Single(); if (values.Contains(selectedValue)) + { pageField.Item = Convert.ToUInt32(values.IndexOf(selectedValue)); + } } else + { throw new NotImplementedException(); + } } orderedPageFields.Add(sortOrderIndex, pageField); } if ((labelOrFilterField?.SelectedValues?.Count ?? 0) > 1) + { pf.MultipleItemSelectionAllowed = true; + } if (pt.Values.Any(p => p.SourceName == xlpf.SourceName)) + { pf.DataField = true; + } var fieldItems = new Items(); @@ -2720,12 +3082,16 @@ private static void GeneratePivotTablePartContent( var item = new Item { Index = i }; if (labelOrFilterField != null && labelOrFilterField.Collapsed) + { item.HideDetails = BooleanValue.FromBoolean(false); + } if (labelOrFilterField != null && labelOrFilterField.SelectedValues.Count > 1 && !labelOrFilterField.SelectedValues.Contains(value)) + { item.Hidden = BooleanValue.FromBoolean(true); + } fieldItems.AppendChild(item); @@ -2819,7 +3185,7 @@ private static void GeneratePivotTablePartContent( var pivotFieldExtension = new PivotFieldExtension { Uri = "{2946ED86-A175-432a-8AC1-64E0C546D7DE}" }; pivotFieldExtension.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"); - var pivotField2 = new DocumentFormat.OpenXml.Office2010.Excel.PivotField { FillDownLabels = true }; + var pivotField2 = new X14.PivotField { FillDownLabels = true }; pivotFieldExtension.AppendChild(pivotField2); @@ -2854,10 +3220,12 @@ private static void GeneratePivotTablePartContent( if (pt.ColumnLabels.All(cl => cl.CustomName == XLConstants.PivotTable.ValuesSentinalLabel)) { - for (int i = 0; i < pt.Values.Count(); i++) + for (var i = 0; i < pt.Values.Count(); i++) { - var rowItem = new RowItem(); - rowItem.Index = Convert.ToUInt32(i); + var rowItem = new RowItem + { + Index = Convert.ToUInt32(i) + }; rowItem.AppendChild(new MemberPropertyIndex() { Val = i }); columnItems.AppendChild(rowItem); } @@ -2888,24 +3256,31 @@ private static void GeneratePivotTablePartContent( { var sourceColumn = pt.SourceRange.Columns().FirstOrDefault(c => c.Cell(1).Value.ObjectToInvariantString() == value.SourceName); - if (sourceColumn == null) continue; + if (sourceColumn == null) + { + continue; + } - UInt32 numberFormatId = 0; + uint numberFormatId = 0; if (value.NumberFormat.NumberFormatId != -1 || context.SharedNumberFormats.ContainsKey(value.NumberFormat.NumberFormatId)) - numberFormatId = (UInt32)value.NumberFormat.NumberFormatId; + { + numberFormatId = (uint)value.NumberFormat.NumberFormatId; + } else if (context.SharedNumberFormats.Any(snf => snf.Value.NumberFormat.Format == value.NumberFormat.Format)) - numberFormatId = (UInt32)context.SharedNumberFormats.First(snf => snf.Value.NumberFormat.Format == value.NumberFormat.Format).Key; + { + numberFormatId = (uint)context.SharedNumberFormats.First(snf => snf.Value.NumberFormat.Format == value.NumberFormat.Format).Key; + } var df = new DataField { Name = value.CustomName, - Field = (UInt32)(sourceColumn.ColumnNumber() - pt.SourceRange.RangeAddress.FirstAddress.ColumnNumber), + Field = (uint)(sourceColumn.ColumnNumber() - pt.SourceRange.RangeAddress.FirstAddress.ColumnNumber), Subtotal = value.SummaryFormula.ToOpenXml(), ShowDataAs = value.Calculation.ToOpenXml(), NumberFormatId = numberFormatId }; - if (!String.IsNullOrEmpty(value.BaseField)) + if (!string.IsNullOrEmpty(value.BaseField)) { var baseField = pt.SourceRange.Columns().FirstOrDefault(c => c.Cell(1).Value.ObjectToInvariantString() == value.BaseField); if (baseField != null) @@ -2918,7 +3293,9 @@ private static void GeneratePivotTablePartContent( .Distinct().ToList(); if (items.Any(i => i.Equals(value.BaseItem))) + { df.BaseItem = Convert.ToUInt32(items.IndexOf(value.BaseItem)); + } } } else @@ -2927,11 +3304,17 @@ private static void GeneratePivotTablePartContent( } if (value.CalculationItem == XLPivotCalculationItem.Previous) + { df.BaseItem = 1048828U; + } else if (value.CalculationItem == XLPivotCalculationItem.Next) + { df.BaseItem = 1048829U; + } else if (df.BaseItem == null || !df.BaseItem.HasValue) + { df.BaseItem = 0U; + } dataFields.AppendChild(df); } @@ -2951,21 +3334,31 @@ private static void GeneratePivotTablePartContent( }; if (pt.Theme != XLPivotTableTheme.None) + { pts.Name = Enum.GetName(typeof(XLPivotTableTheme), pt.Theme); + } pivotTableDefinition.AppendChild(pts); // Pivot formats if (pivotTableDefinition.Formats == null) + { pivotTableDefinition.Formats = new Formats(); + } else + { pivotTableDefinition.Formats.RemoveAllChildren(); + } foreach (var styleFormat in pt.StyleFormats.RowGrandTotalFormats) + { GeneratePivotTableFormat(isRow: true, (XLPivotStyleFormat)styleFormat, pivotTableDefinition, context); + } foreach (var styleFormat in pt.StyleFormats.ColumnGrandTotalFormats) + { GeneratePivotTableFormat(isRow: false, (XLPivotStyleFormat)styleFormat, pivotTableDefinition, context); + } foreach (var pivotField in pt.ImplementedFields) { @@ -2980,7 +3373,9 @@ private static void GeneratePivotTablePartContent( pivotTableDefinition.Formats.Count = new UInt32Value((uint)pivotTableDefinition.Formats.Count()); } else + { pivotTableDefinition.Formats = null; + } #region Excel 2010 Features @@ -2989,7 +3384,7 @@ private static void GeneratePivotTablePartContent( var pivotTableDefinitionExtension = new PivotTableDefinitionExtension { Uri = "{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}" }; pivotTableDefinitionExtension.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"); - var pivotTableDefinition2 = new DocumentFormat.OpenXml.Office2010.Excel.PivotTableDefinition + var pivotTableDefinition2 = new X14.PivotTableDefinition { EnableEdit = pt.EnableCellEditing, HideValuesRow = !pt.ShowValuesRow @@ -3006,14 +3401,17 @@ private static void GeneratePivotTablePartContent( pivotTablePart.PivotTableDefinition = pivotTableDefinition; } - private static void GeneratePivotTableFormat(Boolean isRow, XLPivotStyleFormat styleFormat, PivotTableDefinition pivotTableDefinition, SaveContext context) + private static void GeneratePivotTableFormat(bool isRow, XLPivotStyleFormat styleFormat, PivotTableDefinition pivotTableDefinition, SaveContext context) { if (DefaultStyle.Equals(styleFormat.Style) || !context.DifferentialFormats.ContainsKey(((XLStyle)styleFormat.Style).Value)) + { return; + } - var format = new Format(); - - format.FormatId = UInt32Value.FromUInt32(Convert.ToUInt32(context.DifferentialFormats[((XLStyle)styleFormat.Style).Value])); + var format = new Format + { + FormatId = UInt32Value.FromUInt32(Convert.ToUInt32(context.DifferentialFormats[((XLStyle)styleFormat.Style).Value])) + }; var pivotArea = GenerateDefaultPivotArea(XLPivotStyleFormatTarget.GrandTotal); @@ -3032,14 +3430,19 @@ private static void GeneratePivotTableFormat(Boolean isRow, XLPivotStyleFormat s private static void GeneratePivotFieldFormat(XLPivotStyleFormatTarget target, XLPivotTable pt, XLPivotField pivotField, XLPivotStyleFormat styleFormat, PivotTableDefinition pivotTableDefinition, SaveContext context) { if (target == XLPivotStyleFormatTarget.GrandTotal) + { throw new ArgumentException($"Use {nameof(GeneratePivotTableFormat)} to populate grand total formats."); + } if (DefaultStyle.Equals(styleFormat.Style) || !context.DifferentialFormats.ContainsKey(((XLStyle)styleFormat.Style).Value)) + { return; + } - var format = new Format(); - - format.FormatId = UInt32Value.FromUInt32(Convert.ToUInt32(context.DifferentialFormats[((XLStyle)styleFormat.Style).Value])); + var format = new Format + { + FormatId = UInt32Value.FromUInt32(Convert.ToUInt32(context.DifferentialFormats[((XLStyle)styleFormat.Style).Value])) + }; var pivotArea = GenerateDefaultPivotArea(target); @@ -3053,13 +3456,21 @@ private static void GeneratePivotFieldFormat(XLPivotStyleFormatTarget target, XL pivotArea.Field = pivotField.Offset; if (pivotField.IsOnRowAxis) + { pivotArea.Axis = PivotTableAxisValues.AxisRow; + } else if (pivotField.IsOnColumnAxis) + { pivotArea.Axis = PivotTableAxisValues.AxisColumn; + } else if (pivotField.IsInFilterList) + { pivotArea.Axis = PivotTableAxisValues.AxisPage; + } else + { throw new NotImplementedException(); + } } //Ensure referenced pivot field is added to field references @@ -3069,15 +3480,21 @@ private static void GeneratePivotFieldFormat(XLPivotStyleFormatTarget target, XL }.Contains(target) && !styleFormat.FieldReferences.OfType().Select(fr => fr.PivotField).Contains(pivotField)) { - var fr = new PivotLabelFieldReference(pivotField); - fr.DefaultSubtotal = target == XLPivotStyleFormatTarget.Subtotal; + var fr = new PivotLabelFieldReference(pivotField) + { + DefaultSubtotal = target == XLPivotStyleFormatTarget.Subtotal + }; styleFormat.FieldReferences.Insert(0, fr); } if (pivotArea.PivotAreaReferences == null) + { pivotArea.PivotAreaReferences = new PivotAreaReferences(); + } else + { pivotArea.PivotAreaReferences.RemoveAllChildren(); + } foreach (var fr in styleFormat.FieldReferences) { @@ -3089,7 +3506,9 @@ private static void GeneratePivotFieldFormat(XLPivotStyleFormatTarget target, XL pivotArea.PivotAreaReferences.Count = new UInt32Value((uint)pivotArea.PivotAreaReferences.Count()); } else + { pivotArea.PivotAreaReferences = null; + } format.PivotArea = pivotArea; pivotTableDefinition.Formats.AppendChild(format); @@ -3148,10 +3567,11 @@ private static PivotArea GenerateDefaultPivotArea(XLPivotStyleFormatTarget targe private static void GeneratePivotAreaReference(XLPivotTable pt, PivotAreaReferences pivotAreaReferences, AbstractPivotFieldReference fieldReference, SaveContext context) { - var pivotAreaReference = new PivotAreaReference(); - - pivotAreaReference.DefaultSubtotal = OpenXmlHelper.GetBooleanValue(fieldReference.DefaultSubtotal, false); - pivotAreaReference.Field = fieldReference.GetFieldOffset(); + var pivotAreaReference = new PivotAreaReference + { + DefaultSubtotal = OpenXmlHelper.GetBooleanValue(fieldReference.DefaultSubtotal, false), + Field = fieldReference.GetFieldOffset() + }; var matchedOffsets = fieldReference.Match(context.PivotTables[pt.Guid], pt); foreach (var o in matchedOffsets) @@ -3166,18 +3586,18 @@ private static void GenerateWorksheetCommentsPartContent(WorksheetCommentsPart w XLWorksheet xlWorksheet) { var commentList = new CommentList(); - var authorsDict = new Dictionary(); + var authorsDict = new Dictionary(); foreach (var c in xlWorksheet.Internals.CellsCollection.GetCells(c => c.HasComment)) { var comment = new Comment { Reference = c.Address.ToStringRelative() }; var authorName = c.GetComment().Author; - if (!authorsDict.TryGetValue(authorName, out int authorId)) + if (!authorsDict.TryGetValue(authorName, out var authorId)) { authorId = authorsDict.Count; authorsDict.Add(authorName, authorId); } - comment.AuthorId = (UInt32)authorId; + comment.AuthorId = (uint)authorId; var commentText = new CommentText(); foreach (var rt in c.GetComment()) @@ -3202,59 +3622,57 @@ private static void GenerateWorksheetCommentsPartContent(WorksheetCommentsPart w // Generates content of vmlDrawingPart1. private static bool GenerateVmlDrawingPartContent(VmlDrawingPart vmlDrawingPart, XLWorksheet xlWorksheet) { - using (var ms = new MemoryStream()) - using (var stream = vmlDrawingPart.GetStream(FileMode.OpenOrCreate)) - { - CopyStream(stream, ms); - stream.Position = 0; - var writer = new XmlTextWriter(stream, Encoding.UTF8); - - writer.WriteStartElement("xml"); - - // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.vml.shapetype?view=openxml-2.8.1#remarks - // This element defines a shape template that can be used to create other shapes. - // Shapetype is identical to the shape element(§14.1.2.19) except it cannot reference another shapetype element. - // The type attribute shall not be used with shapetype. - // Attributes defined in the shape override any that appear in the shapetype positioning attributes - // (such as top, width, z-index, rotation, flip) are not passed to a shape from a shapetype. - // To use this element, create a shapetype with a specific id attribute. - // Then create a shape and reference the shapetype's id using the type attribute. - new Vml.Shapetype( - new Vml.Stroke { JoinStyle = Vml.StrokeJoinStyleValues.Miter }, - new Vml.Path { AllowGradientShape = true, ConnectionPointType = ConnectValues.Rectangle } - ) - { - Id = XLConstants.Comment.ShapeTypeId, - CoordinateSize = "21600,21600", - OptionalNumber = 202, - EdgePath = "m,l,21600r21600,l21600,xe", - } - .WriteTo(writer); + using var ms = new MemoryStream(); + using var stream = vmlDrawingPart.GetStream(FileMode.OpenOrCreate); + CopyStream(stream, ms); + stream.Position = 0; + var writer = new XmlTextWriter(stream, Encoding.UTF8); + + writer.WriteStartElement("xml"); + + // https://docs.microsoft.com/en-us/dotnet/api/documentformat.openxml.vml.shapetype?view=openxml-2.8.1#remarks + // This element defines a shape template that can be used to create other shapes. + // Shapetype is identical to the shape element(§14.1.2.19) except it cannot reference another shapetype element. + // The type attribute shall not be used with shapetype. + // Attributes defined in the shape override any that appear in the shapetype positioning attributes + // (such as top, width, z-index, rotation, flip) are not passed to a shape from a shapetype. + // To use this element, create a shapetype with a specific id attribute. + // Then create a shape and reference the shapetype's id using the type attribute. + new Vml.Shapetype( + new Vml.Stroke { JoinStyle = Vml.StrokeJoinStyleValues.Miter }, + new Vml.Path { AllowGradientShape = true, ConnectionPointType = ConnectValues.Rectangle } + ) + { + Id = XLConstants.Comment.ShapeTypeId, + CoordinateSize = "21600,21600", + OptionalNumber = 202, + EdgePath = "m,l,21600r21600,l21600,xe", + } + .WriteTo(writer); - var cellWithComments = xlWorksheet.Internals.CellsCollection.GetCells(c => c.HasComment); + var cellWithComments = xlWorksheet.Internals.CellsCollection.GetCells(c => c.HasComment); - var hasAnyVmlElements = false; + var hasAnyVmlElements = false; - foreach (var c in cellWithComments) - { - GenerateCommentShape(c).WriteTo(writer); - hasAnyVmlElements |= true; - } + foreach (var c in cellWithComments) + { + GenerateCommentShape(c).WriteTo(writer); + hasAnyVmlElements |= true; + } - if (ms.Length > 0) - { - ms.Position = 0; - var xdoc = XDocumentExtensions.Load(ms); - xdoc.Root.Elements().ForEach(e => writer.WriteRaw(e.ToString())); - hasAnyVmlElements |= xdoc.Root.HasElements; - } + if (ms.Length > 0) + { + ms.Position = 0; + var xdoc = XDocumentExtensions.Load(ms); + xdoc.Root.Elements().ForEach(e => writer.WriteRaw(e.ToString())); + hasAnyVmlElements |= xdoc.Root.HasElements; + } - writer.WriteEndElement(); - writer.Flush(); - writer.Close(); + writer.WriteEndElement(); + writer.Flush(); + writer.Close(); - return hasAnyVmlElements; - } + return hasAnyVmlElements; } // VML Shape for Comment @@ -3264,14 +3682,17 @@ private static Vml.Shape GenerateCommentShape(XLCell c) var columnNumber = c.Address.ColumnNumber; var comment = c.GetComment(); - var shapeId = String.Concat("_x0000_s", comment.ShapeId); + var shapeId = string.Concat("_x0000_s", comment.ShapeId); // Unique per cell (workbook?), e.g.: "_x0000_s1026" var anchor = GetAnchor(c); var textBox = GetTextBox(comment.Style); var fill = new Vml.Fill { Color2 = "#" + comment.Style.ColorsAndLines.FillColor.Color.ToHex().Substring(2) }; if (comment.Style.ColorsAndLines.FillTransparency < 1) + { fill.Opacity = Math.Round(Convert.ToDouble(comment.Style.ColorsAndLines.FillTransparency), 2).ToInvariantString(); + } + var stroke = GetStroke(c); var shape = new Vml.Shape( fill, @@ -3304,11 +3725,13 @@ private static Vml.Shape GenerateCommentShape(XLCell c) Style = GetCommentStyle(c), FillColor = "#" + comment.Style.ColorsAndLines.FillColor.Color.ToHex().Substring(2), StrokeColor = "#" + comment.Style.ColorsAndLines.LineColor.Color.ToHex().Substring(2), - StrokeWeight = String.Concat(comment.Style.ColorsAndLines.LineWeight.ToInvariantString(), "pt"), + StrokeWeight = string.Concat(comment.Style.ColorsAndLines.LineWeight.ToInvariantString(), "pt"), InsetMode = comment.Style.Margins.Automatic ? InsetMarginValues.Auto : InsetMarginValues.Custom }; - if (!String.IsNullOrWhiteSpace(comment.Style.Web.AlternateText)) + if (!string.IsNullOrWhiteSpace(comment.Style.Web.AlternateText)) + { shape.Alternate = comment.Style.Web.AlternateText; + } return shape; } @@ -3325,17 +3748,23 @@ private static Vml.Stroke GetStroke(XLCell c) : lineDash.ToString().ToCamel() }; if (lineDash == XLDashStyle.RoundDot) + { stroke.EndCap = Vml.StrokeEndCapValues.Round; + } + if (c.GetComment().Style.ColorsAndLines.LineTransparency < 1) + { stroke.Opacity = Math.Round(Convert.ToDouble(c.GetComment().Style.ColorsAndLines.LineTransparency), 2).ToInvariantString(); + } + return stroke; } // http://polymathprogrammer.com/2009/10/22/english-metric-units-and-open-xml/ // http://archive.oreilly.com/pub/post/what_is_an_emu.html // https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML - private static Int64 ConvertToEnglishMetricUnits(Int32 pixels, Double resolution) + private static long ConvertToEnglishMetricUnits(float pixels, double resolution) { return Convert.ToInt64(914400L * pixels / resolution); } @@ -3347,22 +3776,30 @@ private static void AddPictureAnchor(WorksheetPart worksheetPart, Drawings.IXLPi worksheetPart.AddNewPart(context.RelIdGenerator.GetNext(RelType.Workbook)); if (drawingsPart.WorksheetDrawing == null) + { drawingsPart.WorksheetDrawing = new Xdr.WorksheetDrawing(); + } var worksheetDrawing = drawingsPart.WorksheetDrawing; // Add namespaces if (!worksheetDrawing.NamespaceDeclarations.Any(nd => nd.Value.Equals("http://schemas.openxmlformats.org/drawingml/2006/main"))) + { worksheetDrawing.AddNamespaceDeclaration("a", "http://schemas.openxmlformats.org/drawingml/2006/main"); + } if (!worksheetDrawing.NamespaceDeclarations.Any(nd => nd.Value.Equals("http://schemas.openxmlformats.org/officeDocument/2006/relationships"))) + { worksheetDrawing.AddNamespaceDeclaration("r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"); + } ///////// // Overwrite actual image binary data ImagePart imagePart; if (drawingsPart.HasPartWithId(pic.RelId)) + { imagePart = drawingsPart.GetPartById(pic.RelId) as ImagePart; + } else { pic.RelId = context.RelIdGenerator.GetNext(RelType.Workbook); @@ -3381,10 +3818,12 @@ private static void AddPictureAnchor(WorksheetPart worksheetPart, Drawings.IXLPi // Clear current anchors var existingAnchor = GetAnchorFromImageId(worksheetPart, pic.RelId); if (existingAnchor != null) + { worksheetDrawing.RemoveChild(existingAnchor); + } - var extentsCx = ConvertToEnglishMetricUnits(pic.Width, GraphicsUtils.Graphics.DpiX); - var extentsCy = ConvertToEnglishMetricUnits(pic.Height, GraphicsUtils.Graphics.DpiY); + var extentsCx = ConvertToEnglishMetricUnits(pic.Width, 72); + var extentsCy = ConvertToEnglishMetricUnits(pic.Height, 72); var nvps = worksheetDrawing.Descendants(); var nvpId = nvps.Any() ? @@ -3399,8 +3838,8 @@ private static void AddPictureAnchor(WorksheetPart worksheetPart, Drawings.IXLPi var absoluteAnchor = new Xdr.AbsoluteAnchor( new Xdr.Position { - X = ConvertToEnglishMetricUnits(pic.Left, GraphicsUtils.Graphics.DpiX), - Y = ConvertToEnglishMetricUnits(pic.Top, GraphicsUtils.Graphics.DpiY) + X = ConvertToEnglishMetricUnits(pic.Left, 72), + Y = ConvertToEnglishMetricUnits(pic.Top, 72) }, new Xdr.Extent { @@ -3432,23 +3871,31 @@ private static void AddPictureAnchor(WorksheetPart worksheetPart, Drawings.IXLPi case Drawings.XLPicturePlacement.MoveAndSize: var moveAndSizeFromMarker = pic.Markers[Drawings.XLMarkerPosition.TopLeft]; - if (moveAndSizeFromMarker == null) moveAndSizeFromMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1")); + if (moveAndSizeFromMarker == null) + { + moveAndSizeFromMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1")); + } + fMark = new Xdr.FromMarker { ColumnId = new Xdr.ColumnId((moveAndSizeFromMarker.ColumnNumber - 1).ToInvariantString()), RowId = new Xdr.RowId((moveAndSizeFromMarker.RowNumber - 1).ToInvariantString()), - ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.X, GraphicsUtils.Graphics.DpiX).ToInvariantString()), - RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.Y, GraphicsUtils.Graphics.DpiY).ToInvariantString()) + ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.X, 72).ToInvariantString()), + RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeFromMarker.Offset.Y, 72).ToInvariantString()) }; var moveAndSizeToMarker = pic.Markers[Drawings.XLMarkerPosition.BottomRight]; - if (moveAndSizeToMarker == null) moveAndSizeToMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1"), new System.Drawing.Point(picture.Width, picture.Height)); + if (moveAndSizeToMarker == null) + { + moveAndSizeToMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1"), new SKPoint(picture.Width, picture.Height)); + } + tMark = new Xdr.ToMarker { ColumnId = new Xdr.ColumnId((moveAndSizeToMarker.ColumnNumber - 1).ToInvariantString()), RowId = new Xdr.RowId((moveAndSizeToMarker.RowNumber - 1).ToInvariantString()), - ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.X, GraphicsUtils.Graphics.DpiX).ToInvariantString()), - RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.Y, GraphicsUtils.Graphics.DpiY).ToInvariantString()) + ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.X, 72).ToInvariantString()), + RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveAndSizeToMarker.Offset.Y, 72).ToInvariantString()) }; var twoCellAnchor = new Xdr.TwoCellAnchor( @@ -3479,13 +3926,17 @@ private static void AddPictureAnchor(WorksheetPart worksheetPart, Drawings.IXLPi case Drawings.XLPicturePlacement.Move: var moveFromMarker = pic.Markers[Drawings.XLMarkerPosition.TopLeft]; - if (moveFromMarker == null) moveFromMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1")); + if (moveFromMarker == null) + { + moveFromMarker = new Drawings.XLMarker(picture.Worksheet.Cell("A1")); + } + fMark = new Xdr.FromMarker { ColumnId = new Xdr.ColumnId((moveFromMarker.ColumnNumber - 1).ToInvariantString()), RowId = new Xdr.RowId((moveFromMarker.RowNumber - 1).ToInvariantString()), - ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.X, GraphicsUtils.Graphics.DpiX).ToInvariantString()), - RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.Y, GraphicsUtils.Graphics.DpiY).ToInvariantString()) + ColumnOffset = new Xdr.ColumnOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.X, 72).ToInvariantString()), + RowOffset = new Xdr.RowOffset(ConvertToEnglishMetricUnits(moveFromMarker.Offset.Y, 72).ToInvariantString()) }; var oneCellAnchor = new Xdr.OneCellAnchor( @@ -3536,33 +3987,47 @@ private static Vml.TextBox GetTextBox(IXLDrawingStyle ds) var a = ds.Alignment; if (a.Direction == XLDrawingTextDirection.Context) + { sb.Append("mso-direction-alt:auto;"); + } else if (a.Direction == XLDrawingTextDirection.RightToLeft) + { sb.Append("direction:RTL;"); + } if (a.Orientation != XLDrawingTextOrientation.LeftToRight) { sb.Append("layout-flow:vertical;"); if (a.Orientation == XLDrawingTextOrientation.BottomToTop) + { sb.Append("mso-layout-flow-alt:bottom-to-top;"); + } else if (a.Orientation == XLDrawingTextOrientation.Vertical) + { sb.Append("mso-layout-flow-alt:top-to-bottom;"); + } } if (a.AutomaticSize) + { sb.Append("mso-fit-shape-to-text:t;"); + } var tb = new Vml.TextBox(); if (sb.Length > 0) + { tb.Style = sb.ToString(); + } var dm = ds.Margins; if (!dm.Automatic) - tb.Inset = String.Concat( + { + tb.Inset = string.Concat( dm.Left.ToInvariantString(), "in,", dm.Top.ToInvariantString(), "in,", dm.Right.ToInvariantString(), "in,", dm.Bottom.ToInvariantString(), "in"); + } return tb; } @@ -3637,17 +4102,23 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles var defaultStyle = DefaultStyleValue; if (!context.SharedFonts.ContainsKey(defaultStyle.Font)) + { context.SharedFonts.Add(defaultStyle.Font, new FontInfo { FontId = 0, Font = defaultStyle.Font }); + } if (workbookStylesPart.Stylesheet == null) + { workbookStylesPart.Stylesheet = new Stylesheet(); + } // Cell styles = Named styles if (workbookStylesPart.Stylesheet.CellStyles == null) + { workbookStylesPart.Stylesheet.CellStyles = new CellStyles(); + } // To determine the default workbook style, we look for the style with builtInId = 0 (I hope that is the correct approach) - UInt32 defaultFormatId; + uint defaultFormatId; if (workbookStylesPart.Stylesheet.CellStyles.Elements().Any(c => c.BuiltinId != null && c.BuiltinId.HasValue && c.BuiltinId.Value == 0)) { // Possible to have duplicate default cell styles - occurs when file gets saved under different cultures. @@ -3659,9 +4130,13 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles defaultFormatId = normalCellStyles.Last().FormatId.Value; } else if (workbookStylesPart.Stylesheet.CellStyles.Elements().Any()) + { defaultFormatId = workbookStylesPart.Stylesheet.CellStyles.Elements().Max(c => c.FormatId.Value) + 1; + } else + { defaultFormatId = 0; + } context.SharedStyles.Add(defaultStyle, new StyleInfo @@ -3676,10 +4151,10 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles //AlignmentId = 0 }); - UInt32 styleCount = 1; - UInt32 fontCount = 1; - UInt32 fillCount = 3; - UInt32 borderCount = 1; + uint styleCount = 1; + uint fontCount = 1; + uint fillCount = 3; + uint borderCount = 1; var numberFormatCount = 0; // 0-based var pivotTableNumberFormats = new HashSet(); var xlStyles = new HashSet(); @@ -3702,7 +4177,9 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles } foreach (var ptnf in worksheet.PivotTables.SelectMany(pt => pt.Values.Select(ptv => ptv.NumberFormat)).Distinct().Where(nf => !pivotTableNumberFormats.Contains(nf))) + { pivotTableNumberFormats.Add(ptnf); + } } var alignments = xlStyles.Select(s => s.Alignment).Distinct().ToList(); @@ -3712,11 +4189,11 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles var numberFormats = xlStyles.Select(s => s.NumberFormat).Distinct().ToList(); var protections = xlStyles.Select(s => s.Protection).Distinct().ToList(); - for (int i = 0; i < fonts.Count; i++) + for (var i = 0; i < fonts.Count; i++) { if (!context.SharedFonts.ContainsKey(fonts[i])) { - context.SharedFonts.Add(fonts[i], new FontInfo { FontId = (uint)fontCount++, Font = fonts[i] }); + context.SharedFonts.Add(fonts[i], new FontInfo { FontId = fontCount++, Font = fonts[i] }); } } @@ -3744,7 +4221,9 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles var numberFormat = XLNumberFormatValue.FromKey(ref numberFormatKey); if (sharedNumberFormats.ContainsKey(numberFormat)) + { continue; + } sharedNumberFormats.Add(numberFormat, new NumberFormatInfo @@ -3771,6 +4250,7 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles : allSharedNumberFormats[xlStyle.NumberFormat].NumberFormatId; if (!context.SharedStyles.ContainsKey(xlStyle)) + { context.SharedStyles.Add(xlStyle, new StyleInfo { @@ -3782,15 +4262,18 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles NumberFormatId = numberFormatId, IncludeQuotePrefix = xlStyle.IncludeQuotePrefix }); + } } ResolveCellStyleFormats(workbookStylesPart, context); ResolveRest(workbookStylesPart, context); if (!workbookStylesPart.Stylesheet.CellStyles.Elements().Any(c => c.BuiltinId != null && c.BuiltinId.HasValue && c.BuiltinId.Value == 0U)) + { workbookStylesPart.Stylesheet.CellStyles.AppendChild(new CellStyle { Name = "Normal", FormatId = defaultFormatId, BuiltinId = 0U }); + } - workbookStylesPart.Stylesheet.CellStyles.Count = (UInt32)workbookStylesPart.Stylesheet.CellStyles.Count(); + workbookStylesPart.Stylesheet.CellStyles.Count = (uint)workbookStylesPart.Stylesheet.CellStyles.Count(); var newSharedStyles = new Dictionary(); foreach (var ss in context.SharedStyles) @@ -3800,12 +4283,17 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles { styleId++; if (CellFormatsAreEqual(f, ss.Value, compareAlignment: true)) + { break; + } } if (styleId == -1) + { styleId = 0; + } + var si = ss.Value; - si.StyleId = (UInt32)styleId; + si.StyleId = (uint)styleId; newSharedStyles.Add(ss.Key, si); } context.SharedStyles.Clear(); @@ -3822,7 +4310,9 @@ private void GenerateWorkbookStylesPartContent(WorkbookStylesPart workbookStyles private void AddDifferentialFormats(WorkbookStylesPart workbookStylesPart, SaveContext context) { if (workbookStylesPart.Stylesheet.DifferentialFormats == null) + { workbookStylesPart.Stylesheet.DifferentialFormats = new DifferentialFormats(); + } var differentialFormats = workbookStylesPart.Stylesheet.DifferentialFormats; differentialFormats.RemoveAllChildren(); @@ -3834,7 +4324,9 @@ private void AddDifferentialFormats(WorkbookStylesPart workbookStylesPart, SaveC { var styleValue = (cf.Style as XLStyle).Value; if (!styleValue.Equals(DefaultStyleValue) && !context.DifferentialFormats.ContainsKey(styleValue)) + { AddConditionalDifferentialFormat(workbookStylesPart.Stylesheet.DifferentialFormats, cf, context); + } } foreach (var tf in ws.Tables.SelectMany(t => t.Fields)) @@ -3847,7 +4339,9 @@ private void AddDifferentialFormats(WorkbookStylesPart workbookStylesPart, SaveC .Style as XLStyle).Value; if (!style.Equals(DefaultStyleValue) && !context.DifferentialFormats.ContainsKey(style)) + { AddStyleAsDifferentialFormat(workbookStylesPart.Stylesheet.DifferentialFormats, style, context); + } } } @@ -3857,14 +4351,18 @@ private void AddDifferentialFormats(WorkbookStylesPart workbookStylesPart, SaveC { var xlStyle = (XLStyle)styleFormat.Style; if (!xlStyle.Value.Equals(DefaultStyleValue) && !context.DifferentialFormats.ContainsKey(xlStyle.Value)) + { AddStyleAsDifferentialFormat(workbookStylesPart.Stylesheet.DifferentialFormats, xlStyle.Value, context); + } } } } - differentialFormats.Count = (UInt32)differentialFormats.Count(); + differentialFormats.Count = (uint)differentialFormats.Count(); if (differentialFormats.Count == 0) + { workbookStylesPart.Stylesheet.DifferentialFormats = null; + } } private void FillDifferentialFormatsCollection(DifferentialFormats differentialFormats, @@ -3884,7 +4382,9 @@ private void FillDifferentialFormatsCollection(DifferentialFormats differentialF LoadFill(df.Fill, emptyContainer.Style.Fill, differentialFillFormat: true); if (!dictionary.ContainsKey(emptyContainer.StyleValue)) + { dictionary.Add(emptyContainer.StyleValue, id++); + } } } @@ -3896,13 +4396,15 @@ private static void AddConditionalDifferentialFormat(DifferentialFormats differe var diffFont = GetNewFont(new FontInfo { Font = styleValue.Font }, false); if (diffFont?.HasChildren ?? false) + { differentialFormat.Append(diffFont); + } - if (!String.IsNullOrWhiteSpace(cf.Style.NumberFormat.Format)) + if (!string.IsNullOrWhiteSpace(cf.Style.NumberFormat.Format)) { var numberFormat = new NumberingFormat { - NumberFormatId = (UInt32)(XLConstants.NumberOfBuiltInStyles + differentialFormats.Count()), + NumberFormatId = (uint)(XLConstants.NumberOfBuiltInStyles + differentialFormats.Count()), FormatCode = cf.Style.NumberFormat.Format }; differentialFormat.Append(numberFormat); @@ -3910,11 +4412,15 @@ private static void AddConditionalDifferentialFormat(DifferentialFormats differe var diffFill = GetNewFill(new FillInfo { Fill = styleValue.Fill }, differentialFillFormat: true, ignoreMod: false); if (diffFill?.HasChildren ?? false) + { differentialFormat.Append(diffFill); + } var diffBorder = GetNewBorder(new BorderInfo { Border = styleValue.Border }, false); if (diffBorder?.HasChildren ?? false) + { differentialFormat.Append(diffBorder); + } differentialFormats.Append(differentialFormat); @@ -3928,27 +4434,33 @@ private static void AddStyleAsDifferentialFormat(DifferentialFormats differentia var diffFont = GetNewFont(new FontInfo { Font = style.Font }, false); if (diffFont?.HasChildren ?? false) + { differentialFormat.Append(diffFont); + } - if (!String.IsNullOrWhiteSpace(style.NumberFormat.Format) || style.NumberFormat.NumberFormatId != 0) + if (!string.IsNullOrWhiteSpace(style.NumberFormat.Format) || style.NumberFormat.NumberFormatId != 0) { var numberFormat = new NumberingFormat(); if (style.NumberFormat.NumberFormatId == -1) { numberFormat.FormatCode = style.NumberFormat.Format; - numberFormat.NumberFormatId = (UInt32)(XLConstants.NumberOfBuiltInStyles + + numberFormat.NumberFormatId = (uint)(XLConstants.NumberOfBuiltInStyles + differentialFormats .Descendants() .Count(df => df.NumberingFormat != null && df.NumberingFormat.NumberFormatId != null && df.NumberingFormat.NumberFormatId.Value >= XLConstants.NumberOfBuiltInStyles)); } else { - numberFormat.NumberFormatId = (UInt32)(style.NumberFormat.NumberFormatId); + numberFormat.NumberFormatId = (uint)style.NumberFormat.NumberFormatId; if (!string.IsNullOrEmpty(style.NumberFormat.Format)) + { numberFormat.FormatCode = style.NumberFormat.Format; - else if (XLPredefinedFormat.FormatCodes.TryGetValue(style.NumberFormat.NumberFormatId, out string formatCode)) + } + else if (XLPredefinedFormat.FormatCodes.TryGetValue(style.NumberFormat.NumberFormatId, out var formatCode)) + { numberFormat.FormatCode = formatCode; + } } differentialFormat.Append(numberFormat); @@ -3956,11 +4468,15 @@ private static void AddStyleAsDifferentialFormat(DifferentialFormats differentia var diffFill = GetNewFill(new FillInfo { Fill = style.Fill }, differentialFillFormat: true, ignoreMod: false); if (diffFill?.HasChildren ?? false) + { differentialFormat.Append(diffFill); + } var diffBorder = GetNewBorder(new BorderInfo { Border = style.Border }, false); if (diffBorder?.HasChildren ?? false) + { differentialFormat.Append(diffBorder); + } differentialFormats.Append(differentialFormat); @@ -3970,7 +4486,9 @@ private static void AddStyleAsDifferentialFormat(DifferentialFormats differentia private static void ResolveRest(WorkbookStylesPart workbookStylesPart, SaveContext context) { if (workbookStylesPart.Stylesheet.CellFormats == null) + { workbookStylesPart.Stylesheet.CellFormats = new CellFormats(); + } foreach (var styleInfo in context.SharedStyles.Values) { @@ -3978,7 +4496,10 @@ private static void ResolveRest(WorkbookStylesPart workbookStylesPart, SaveConte var foundOne = workbookStylesPart.Stylesheet.CellFormats.Cast().Any(f => CellFormatsAreEqual(f, info, compareAlignment: true)); - if (foundOne) continue; + if (foundOne) + { + continue; + } var cellFormat = GetCellFormat(styleInfo); cellFormat.FormatId = 0; @@ -3986,10 +4507,10 @@ private static void ResolveRest(WorkbookStylesPart workbookStylesPart, SaveConte { Horizontal = styleInfo.Style.Alignment.Horizontal.ToOpenXml(), Vertical = styleInfo.Style.Alignment.Vertical.ToOpenXml(), - Indent = (UInt32)styleInfo.Style.Alignment.Indent, - ReadingOrder = (UInt32)styleInfo.Style.Alignment.ReadingOrder, + Indent = (uint)styleInfo.Style.Alignment.Indent, + ReadingOrder = (uint)styleInfo.Style.Alignment.ReadingOrder, WrapText = styleInfo.Style.Alignment.WrapText, - TextRotation = (UInt32)styleInfo.Style.Alignment.TextRotation, + TextRotation = (uint)styleInfo.Style.Alignment.TextRotation, ShrinkToFit = styleInfo.Style.Alignment.ShrinkToFit, RelativeIndent = styleInfo.Style.Alignment.RelativeIndent, JustifyLastLine = styleInfo.Style.Alignment.JustifyLastLine @@ -3997,18 +4518,22 @@ private static void ResolveRest(WorkbookStylesPart workbookStylesPart, SaveConte cellFormat.AppendChild(alignment); if (cellFormat.ApplyProtection.Value) + { cellFormat.AppendChild(GetProtection(styleInfo)); + } workbookStylesPart.Stylesheet.CellFormats.AppendChild(cellFormat); } - workbookStylesPart.Stylesheet.CellFormats.Count = (UInt32)workbookStylesPart.Stylesheet.CellFormats.Count(); + workbookStylesPart.Stylesheet.CellFormats.Count = (uint)workbookStylesPart.Stylesheet.CellFormats.Count(); } private static void ResolveCellStyleFormats(WorkbookStylesPart workbookStylesPart, SaveContext context) { if (workbookStylesPart.Stylesheet.CellStyleFormats == null) + { workbookStylesPart.Stylesheet.CellStyleFormats = new CellStyleFormats(); + } foreach (var styleInfo in context.SharedStyles.Values) { @@ -4017,17 +4542,22 @@ private static void ResolveCellStyleFormats(WorkbookStylesPart workbookStylesPar workbookStylesPart.Stylesheet.CellStyleFormats.Cast().Any( f => CellFormatsAreEqual(f, info, compareAlignment: false)); - if (foundOne) continue; + if (foundOne) + { + continue; + } var cellStyleFormat = GetCellFormat(styleInfo); if (cellStyleFormat.ApplyProtection.Value) + { cellStyleFormat.AppendChild(GetProtection(styleInfo)); + } workbookStylesPart.Stylesheet.CellStyleFormats.AppendChild(cellStyleFormat); } workbookStylesPart.Stylesheet.CellStyleFormats.Count = - (UInt32)workbookStylesPart.Stylesheet.CellStyleFormats.Count(); + (uint)workbookStylesPart.Stylesheet.CellStyleFormats.Count(); } private static bool ApplyFill(StyleInfo styleInfo) @@ -4038,11 +4568,11 @@ private static bool ApplyFill(StyleInfo styleInfo) private static bool ApplyBorder(StyleInfo styleInfo) { var opBorder = styleInfo.Style.Border; - return (opBorder.BottomBorder.ToOpenXml() != BorderStyleValues.None + return opBorder.BottomBorder.ToOpenXml() != BorderStyleValues.None || opBorder.DiagonalBorder.ToOpenXml() != BorderStyleValues.None || opBorder.RightBorder.ToOpenXml() != BorderStyleValues.None || opBorder.LeftBorder.ToOpenXml() != BorderStyleValues.None - || opBorder.TopBorder.ToOpenXml() != BorderStyleValues.None); + || opBorder.TopBorder.ToOpenXml() != BorderStyleValues.None; } private static bool ApplyProtection(StyleInfo styleInfo) @@ -4054,7 +4584,7 @@ private static CellFormat GetCellFormat(StyleInfo styleInfo) { var cellFormat = new CellFormat { - NumberFormatId = (UInt32)styleInfo.NumberFormatId, + NumberFormatId = (uint)styleInfo.NumberFormatId, FontId = styleInfo.FontId, FillId = styleInfo.FillId, BorderId = styleInfo.BorderId, @@ -4110,14 +4640,19 @@ private static bool ProtectionsAreEqual(Protection protection, XLProtectionValue if (protection != null) { if (protection.Locked != null) + { p.Locked = protection.Locked.Value; + } + if (protection.Hidden != null) + { p.Hidden = protection.Hidden.Value; + } } return p.Equals(xlProtection.Key); } - private static bool QuotePrefixesAreEqual(BooleanValue quotePrefix, Boolean includeQuotePrefix) + private static bool QuotePrefixesAreEqual(BooleanValue quotePrefix, bool includeQuotePrefix) { return OpenXmlHelper.GetBooleanValueAsBool(quotePrefix, false) == includeQuotePrefix; } @@ -4128,25 +4663,50 @@ private static bool AlignmentsAreEqual(Alignment alignment, XLAlignmentValue xlA { var a = XLAlignmentValue.Default.Key; if (alignment.Indent != null) - a.Indent = (Int32)alignment.Indent.Value; + { + a.Indent = (int)alignment.Indent.Value; + } if (alignment.Horizontal != null) + { a.Horizontal = alignment.Horizontal.Value.ToClosedXml(); + } + if (alignment.Vertical != null) + { a.Vertical = alignment.Vertical.Value.ToClosedXml(); + } if (alignment.ReadingOrder != null) + { a.ReadingOrder = alignment.ReadingOrder.Value.ToClosedXml(); + } + if (alignment.WrapText != null) + { a.WrapText = alignment.WrapText.Value; + } + if (alignment.TextRotation != null) - a.TextRotation = (Int32)alignment.TextRotation.Value; + { + a.TextRotation = (int)alignment.TextRotation.Value; + } + if (alignment.ShrinkToFit != null) + { a.ShrinkToFit = alignment.ShrinkToFit.Value; + } + if (alignment.RelativeIndent != null) + { a.RelativeIndent = alignment.RelativeIndent.Value; + } + if (alignment.JustifyLastLine != null) + { a.JustifyLastLine = alignment.JustifyLastLine.Value; + } + return a.Equals(xlAlignment.Key); } else @@ -4159,7 +4719,9 @@ private Dictionary ResolveBorders(WorkbookStylesPart Dictionary sharedBorders) { if (workbookStylesPart.Stylesheet.Borders == null) + { workbookStylesPart.Stylesheet.Borders = new Borders(); + } var allSharedBorders = new Dictionary(); foreach (var borderInfo in sharedBorders.Values) @@ -4181,20 +4743,24 @@ private Dictionary ResolveBorders(WorkbookStylesPart workbookStylesPart.Stylesheet.Borders.AppendChild(border); } allSharedBorders.Add(borderInfo.Border, - new BorderInfo { Border = borderInfo.Border, BorderId = (UInt32)borderId }); + new BorderInfo { Border = borderInfo.Border, BorderId = (uint)borderId }); } - workbookStylesPart.Stylesheet.Borders.Count = (UInt32)workbookStylesPart.Stylesheet.Borders.Count(); + workbookStylesPart.Stylesheet.Borders.Count = (uint)workbookStylesPart.Stylesheet.Borders.Count(); return allSharedBorders; } - private static Border GetNewBorder(BorderInfo borderInfo, Boolean ignoreMod = true) + private static Border GetNewBorder(BorderInfo borderInfo, bool ignoreMod = true) { var border = new Border(); if (borderInfo.Border.DiagonalUp != XLBorderValue.Default.DiagonalUp || ignoreMod) + { border.DiagonalUp = borderInfo.Border.DiagonalUp; + } if (borderInfo.Border.DiagonalDown != XLBorderValue.Default.DiagonalDown || ignoreMod) + { border.DiagonalDown = borderInfo.Border.DiagonalDown; + } if (borderInfo.Border.LeftBorder != XLBorderValue.Default.LeftBorder || ignoreMod) { @@ -4243,12 +4809,12 @@ private static Border GetNewBorder(BorderInfo borderInfo, Boolean ignoreMod = tr if (borderInfo.Border.DiagonalBorder != XLBorderValue.Default.DiagonalBorder || ignoreMod) { var DiagonalBorder = new DiagonalBorder { Style = borderInfo.Border.DiagonalBorder.ToOpenXml() }; - if (borderInfo.Border.DiagonalBorderColor != XLBorderValue.Default.DiagonalBorderColor || ignoreMod) - if (borderInfo.Border.DiagonalBorderColor != null) - { - var DiagonalBorderColor = new Color().FromClosedXMLColor(borderInfo.Border.DiagonalBorderColor); - DiagonalBorder.AppendChild(DiagonalBorderColor); - } + if ((borderInfo.Border.DiagonalBorderColor != XLBorderValue.Default.DiagonalBorderColor || ignoreMod) && borderInfo.Border.DiagonalBorderColor != null) + { + var DiagonalBorderColor = new Color().FromClosedXMLColor(borderInfo.Border.DiagonalBorderColor); + DiagonalBorder.AppendChild(DiagonalBorderColor); + } + border.AppendChild(DiagonalBorder); } @@ -4259,49 +4825,78 @@ private bool BordersAreEqual(Border b, XLBorderValue xlBorder) { var nb = XLBorderValue.Default.Key; if (b.DiagonalUp != null) + { nb.DiagonalUp = b.DiagonalUp.Value; + } if (b.DiagonalDown != null) + { nb.DiagonalDown = b.DiagonalDown.Value; + } if (b.DiagonalBorder != null) { if (b.DiagonalBorder.Style != null) + { nb.DiagonalBorder = b.DiagonalBorder.Style.Value.ToClosedXml(); + } + if (b.DiagonalBorder.Color != null) + { nb.DiagonalBorderColor = b.DiagonalBorder.Color.ToClosedXMLColor(_colorList).Key; + } } if (b.LeftBorder != null) { if (b.LeftBorder.Style != null) + { nb.LeftBorder = b.LeftBorder.Style.Value.ToClosedXml(); + } + if (b.LeftBorder.Color != null) + { nb.LeftBorderColor = b.LeftBorder.Color.ToClosedXMLColor(_colorList).Key; + } } if (b.RightBorder != null) { if (b.RightBorder.Style != null) + { nb.RightBorder = b.RightBorder.Style.Value.ToClosedXml(); + } + if (b.RightBorder.Color != null) + { nb.RightBorderColor = b.RightBorder.Color.ToClosedXMLColor(_colorList).Key; + } } if (b.TopBorder != null) { if (b.TopBorder.Style != null) + { nb.TopBorder = b.TopBorder.Style.Value.ToClosedXml(); + } + if (b.TopBorder.Color != null) + { nb.TopBorderColor = b.TopBorder.Color.ToClosedXMLColor(_colorList).Key; + } } if (b.BottomBorder != null) { if (b.BottomBorder.Style != null) + { nb.BottomBorder = b.BottomBorder.Style.Value.ToClosedXml(); + } + if (b.BottomBorder.Color != null) + { nb.BottomBorderColor = b.BottomBorder.Color.ToClosedXMLColor(_colorList).Key; + } } return nb.Equals(xlBorder.Key); @@ -4311,7 +4906,9 @@ private Dictionary ResolveFills(WorkbookStylesPart workbo Dictionary sharedFills) { if (workbookStylesPart.Stylesheet.Fills == null) + { workbookStylesPart.Stylesheet.Fills = new Fills(); + } ResolveFillWithPattern(workbookStylesPart.Stylesheet.Fills, PatternValues.None); ResolveFillWithPattern(workbookStylesPart.Stylesheet.Fills, PatternValues.Gray125); @@ -4335,10 +4932,10 @@ private Dictionary ResolveFills(WorkbookStylesPart workbo var fill = GetNewFill(fillInfo, differentialFillFormat: false); workbookStylesPart.Stylesheet.Fills.AppendChild(fill); } - allSharedFills.Add(fillInfo.Fill, new FillInfo { Fill = fillInfo.Fill, FillId = (UInt32)fillId }); + allSharedFills.Add(fillInfo.Fill, new FillInfo { Fill = fillInfo.Fill, FillId = (uint)fillId }); } - workbookStylesPart.Stylesheet.Fills.Count = (UInt32)workbookStylesPart.Stylesheet.Fills.Count(); + workbookStylesPart.Stylesheet.Fills.Count = (uint)workbookStylesPart.Stylesheet.Fills.Count(); return allSharedFills; } @@ -4350,7 +4947,9 @@ private static void ResolveFillWithPattern(Fills fills, PatternValues patternVal && f.PatternFill.ForegroundColor == null && f.PatternFill.BackgroundColor == null ))) + { return; + } var fill1 = new Fill(); var patternFill1 = new PatternFill { PatternType = patternValues }; @@ -4358,13 +4957,14 @@ private static void ResolveFillWithPattern(Fills fills, PatternValues patternVal fills.AppendChild(fill1); } - private static Fill GetNewFill(FillInfo fillInfo, Boolean differentialFillFormat, Boolean ignoreMod = true) + private static Fill GetNewFill(FillInfo fillInfo, bool differentialFillFormat, bool ignoreMod = true) { var fill = new Fill(); - var patternFill = new PatternFill(); - - patternFill.PatternType = fillInfo.Fill.PatternType.ToOpenXml(); + var patternFill = new PatternFill + { + PatternType = fillInfo.Fill.PatternType.ToOpenXml() + }; BackgroundColor backgroundColor; ForegroundColor foregroundColor; @@ -4381,14 +4981,18 @@ private static Fill GetNewFill(FillInfo fillInfo, Boolean differentialFillFormat patternFill.AppendChild(new ForegroundColor { Auto = true }); backgroundColor = new BackgroundColor().FromClosedXMLColor(fillInfo.Fill.BackgroundColor, true); if (backgroundColor.HasAttributes) + { patternFill.AppendChild(backgroundColor); + } } else { // ClosedXML Background color to be populated into OpenXML fgColor foregroundColor = new ForegroundColor().FromClosedXMLColor(fillInfo.Fill.BackgroundColor); if (foregroundColor.HasAttributes) + { patternFill.AppendChild(foregroundColor); + } } break; @@ -4396,22 +5000,28 @@ private static Fill GetNewFill(FillInfo fillInfo, Boolean differentialFillFormat foregroundColor = new ForegroundColor().FromClosedXMLColor(fillInfo.Fill.PatternColor); if (foregroundColor.HasAttributes) + { patternFill.AppendChild(foregroundColor); + } backgroundColor = new BackgroundColor().FromClosedXMLColor(fillInfo.Fill.BackgroundColor); if (backgroundColor.HasAttributes) + { patternFill.AppendChild(backgroundColor); + } break; } if (patternFill.HasChildren) + { fill.AppendChild(patternFill); + } return fill; } - private bool FillsAreEqual(Fill f, XLFillValue xlFill, Boolean fromDifferentialFormat) + private bool FillsAreEqual(Fill f, XLFillValue xlFill, bool fromDifferentialFormat) { var nF = new XLFill(null); @@ -4423,7 +5033,9 @@ private bool FillsAreEqual(Fill f, XLFillValue xlFill, Boolean fromDifferentialF private void ResolveFonts(WorkbookStylesPart workbookStylesPart, SaveContext context) { if (workbookStylesPart.Stylesheet.Fonts == null) + { workbookStylesPart.Stylesheet.Fonts = new Fonts(); + } var newFonts = new Dictionary(); foreach (var fontInfo in context.SharedFonts.Values) @@ -4444,16 +5056,18 @@ private void ResolveFonts(WorkbookStylesPart workbookStylesPart, SaveContext con var font = GetNewFont(fontInfo); workbookStylesPart.Stylesheet.Fonts.AppendChild(font); } - newFonts.Add(fontInfo.Font, new FontInfo { Font = fontInfo.Font, FontId = (UInt32)fontId }); + newFonts.Add(fontInfo.Font, new FontInfo { Font = fontInfo.Font, FontId = (uint)fontId }); } context.SharedFonts.Clear(); foreach (var kp in newFonts) + { context.SharedFonts.Add(kp.Key, kp.Value); + } - workbookStylesPart.Stylesheet.Fonts.Count = (UInt32)workbookStylesPart.Stylesheet.Fonts.Count(); + workbookStylesPart.Stylesheet.Fonts.Count = (uint)workbookStylesPart.Stylesheet.Fonts.Count(); } - private static Font GetNewFont(FontInfo fontInfo, Boolean ignoreMod = true) + private static Font GetNewFont(FontInfo fontInfo, bool ignoreMod = true) { var font = new Font(); var bold = (fontInfo.Font.Bold != XLFontValue.Default.Bold || ignoreMod) && fontInfo.Font.Bold ? new Bold() : null; @@ -4479,35 +5093,67 @@ private static Font GetNewFont(FontInfo fontInfo, Boolean ignoreMod = true) ? new FontName { Val = fontInfo.Font.FontName } : null; var fontFamilyNumbering = fontInfo.Font.FontFamilyNumbering != XLFontValue.Default.FontFamilyNumbering || ignoreMod - ? new FontFamilyNumbering { Val = (Int32)fontInfo.Font.FontFamilyNumbering } + ? new FontFamilyNumbering { Val = (int)fontInfo.Font.FontFamilyNumbering } : null; var fontCharSet = (fontInfo.Font.FontCharSet != XLFontValue.Default.FontCharSet || ignoreMod) && fontInfo.Font.FontCharSet != XLFontCharSet.Default - ? new FontCharSet { Val = (Int32)fontInfo.Font.FontCharSet } + ? new FontCharSet { Val = (int)fontInfo.Font.FontCharSet } : null; if (bold != null) + { font.AppendChild(bold); + } + if (italic != null) + { font.AppendChild(italic); + } + if (underline != null) + { font.AppendChild(underline); + } + if (strike != null) + { font.AppendChild(strike); + } + if (verticalAlignment != null) + { font.AppendChild(verticalAlignment); + } + if (shadow != null) + { font.AppendChild(shadow); + } + if (fontSize != null) + { font.AppendChild(fontSize); + } + if (color != null) + { font.AppendChild(color); + } + if (fontName != null) + { font.AppendChild(fontName); + } + if (fontFamilyNumbering != null) + { font.AppendChild(fontFamilyNumbering); + } + if (fontCharSet != null) + { font.AppendChild(fontCharSet); + } return font; } @@ -4533,13 +5179,24 @@ private bool FontsAreEqual(Font f, XLFontValue xlFont) } nf.Shadow = f.Shadow != null; if (f.FontSize != null) + { nf.FontSize = f.FontSize.Val; + } + if (f.Color != null) + { nf.FontColor = f.Color.ToClosedXMLColor(_colorList).Key; + } + if (f.FontName != null) + { nf.FontName = f.FontName.Val; + } + if (f.FontFamilyNumbering != null) + { nf.FontFamilyNumbering = (XLFontFamilyNumberingValues)f.FontFamilyNumbering.Val.Value; + } return nf.Equals(xlFont.Key); } @@ -4547,7 +5204,7 @@ private bool FontsAreEqual(Font f, XLFontValue xlFont) private static Dictionary ResolveNumberFormats( WorkbookStylesPart workbookStylesPart, Dictionary sharedNumberFormats, - UInt32 defaultFormatId) + uint defaultFormatId) { if (workbookStylesPart.Stylesheet.NumberingFormats == null) { @@ -4569,7 +5226,7 @@ private static Dictionary ResolveNumberFo if (NumberFormatsAreEqual(nf, numberFormatInfo.NumberFormat)) { foundOne = true; - numberingFormatId = (Int32)nf.NumberFormatId.Value; + numberingFormatId = (int)nf.NumberFormatId.Value; break; } numberingFormatId++; @@ -4578,7 +5235,7 @@ private static Dictionary ResolveNumberFo { var numberingFormat = new NumberingFormat { - NumberFormatId = (UInt32)numberingFormatId, + NumberFormatId = (uint)numberingFormatId, FormatCode = numberFormatInfo.NumberFormat.Format }; workbookStylesPart.Stylesheet.NumberingFormats.AppendChild(numberingFormat); @@ -4591,16 +5248,21 @@ private static Dictionary ResolveNumberFo }); } workbookStylesPart.Stylesheet.NumberingFormats.Count = - (UInt32)workbookStylesPart.Stylesheet.NumberingFormats.Count(); + (uint)workbookStylesPart.Stylesheet.NumberingFormats.Count(); return allSharedNumberFormats; } private static bool NumberFormatsAreEqual(NumberingFormat nf, XLNumberFormatValue xlNumberFormat) { - if (nf.FormatCode != null && !String.IsNullOrWhiteSpace(nf.FormatCode.Value)) + if (nf.FormatCode != null && !string.IsNullOrWhiteSpace(nf.FormatCode.Value)) + { return string.Equals(xlNumberFormat?.Format, nf.FormatCode.Value); + } else if (nf.NumberFormatId != null) - return xlNumberFormat?.NumberFormatId == (Int32)nf.NumberFormatId.Value; + { + return xlNumberFormat?.NumberFormatId == (int)nf.NumberFormatId.Value; + } + return false; } @@ -4619,10 +5281,12 @@ private static void GenerateWorksheetPartContent( #region Worksheet if (worksheetPart.Worksheet == null) + { worksheetPart.Worksheet = new Worksheet(); + } if ( - !worksheetPart.Worksheet.NamespaceDeclarations.Contains(new KeyValuePair("r", + !worksheetPart.Worksheet.NamespaceDeclarations.Contains(new KeyValuePair("r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"))) { worksheetPart.Worksheet.AddNamespaceDeclaration("r", @@ -4636,7 +5300,9 @@ private static void GenerateWorksheetPartContent( #region SheetProperties if (worksheetPart.Worksheet.SheetProperties == null) + { worksheetPart.Worksheet.SheetProperties = new SheetProperties(); + } worksheetPart.Worksheet.SheetProperties.TabColor = xlWorksheet.TabColor.HasValue ? new TabColor().FromClosedXMLColor(xlWorksheet.TabColor) @@ -4645,18 +5311,22 @@ private static void GenerateWorksheetPartContent( cm.SetElement(XLWorksheetContents.SheetProperties, worksheetPart.Worksheet.SheetProperties); if (worksheetPart.Worksheet.SheetProperties.OutlineProperties == null) + { worksheetPart.Worksheet.SheetProperties.OutlineProperties = new OutlineProperties(); + } worksheetPart.Worksheet.SheetProperties.OutlineProperties.SummaryBelow = - (xlWorksheet.Outline.SummaryVLocation == - XLOutlineSummaryVLocation.Bottom); + xlWorksheet.Outline.SummaryVLocation == + XLOutlineSummaryVLocation.Bottom; worksheetPart.Worksheet.SheetProperties.OutlineProperties.SummaryRight = - (xlWorksheet.Outline.SummaryHLocation == - XLOutlineSummaryHLocation.Right); + xlWorksheet.Outline.SummaryHLocation == + XLOutlineSummaryHLocation.Right; if (worksheetPart.Worksheet.SheetProperties.PageSetupProperties == null && (xlWorksheet.PageSetup.PagesTall > 0 || xlWorksheet.PageSetup.PagesWide > 0)) + { worksheetPart.Worksheet.SheetProperties.PageSetupProperties = new PageSetupProperties { FitToPage = true }; + } #endregion SheetProperties @@ -4675,18 +5345,24 @@ private static void GenerateWorksheetPartContent( { var maxColCollection = xlWorksheet.Internals.ColumnsCollection.Keys.Max(); if (maxColCollection > maxColumn) + { maxColumn = maxColCollection; + } } #region SheetViews if (worksheetPart.Worksheet.SheetDimension == null) + { worksheetPart.Worksheet.SheetDimension = new SheetDimension { Reference = sheetDimensionReference }; + } cm.SetElement(XLWorksheetContents.SheetDimension, worksheetPart.Worksheet.SheetDimension); if (worksheetPart.Worksheet.SheetViews == null) + { worksheetPart.Worksheet.SheetViews = new SheetViews(); + } cm.SetElement(XLWorksheetContents.SheetViews, worksheetPart.Worksheet.SheetViews); @@ -4700,59 +5376,103 @@ private static void GenerateWorksheetPartContent( var svcm = new XLSheetViewContentManager(sheetView); if (xlWorksheet.TabSelected) + { sheetView.TabSelected = true; + } else + { sheetView.TabSelected = null; + } if (xlWorksheet.RightToLeft) + { sheetView.RightToLeft = true; + } else + { sheetView.RightToLeft = null; + } if (xlWorksheet.ShowFormulas) + { sheetView.ShowFormulas = true; + } else + { sheetView.ShowFormulas = null; + } if (xlWorksheet.ShowGridLines) + { sheetView.ShowGridLines = null; + } else + { sheetView.ShowGridLines = false; + } if (xlWorksheet.ShowOutlineSymbols) + { sheetView.ShowOutlineSymbols = null; + } else + { sheetView.ShowOutlineSymbols = false; + } if (xlWorksheet.ShowRowColHeaders) + { sheetView.ShowRowColHeaders = null; + } else + { sheetView.ShowRowColHeaders = false; + } if (xlWorksheet.ShowRuler) + { sheetView.ShowRuler = null; + } else + { sheetView.ShowRuler = false; + } if (xlWorksheet.ShowWhiteSpace) + { sheetView.ShowWhiteSpace = null; + } else + { sheetView.ShowWhiteSpace = false; + } if (xlWorksheet.ShowZeros) + { sheetView.ShowZeros = null; + } else + { sheetView.ShowZeros = false; + } if (xlWorksheet.RightToLeft) + { sheetView.RightToLeft = true; + } else + { sheetView.RightToLeft = null; + } if (xlWorksheet.SheetView.View == XLSheetViewOptions.Normal) + { sheetView.View = null; + } else + { sheetView.View = xlWorksheet.SheetView.View.ToOpenXml(); + } var pane = sheetView.Elements().FirstOrDefault(); if (pane == null) @@ -4764,8 +5484,8 @@ private static void GenerateWorksheetPartContent( svcm.SetElement(XLSheetViewContents.Pane, pane); pane.State = PaneStateValues.FrozenSplit; - int hSplit = xlWorksheet.SheetView.SplitColumn; - int ySplit = xlWorksheet.SheetView.SplitRow; + var hSplit = xlWorksheet.SheetView.SplitColumn; + var ySplit = xlWorksheet.SheetView.SplitRow; pane.HorizontalSplit = hSplit; pane.VerticalSplit = ySplit; @@ -4787,9 +5507,13 @@ private static void GenerateWorksheetPartContent( // Do sheet view. Whether it's for a regular sheet or for the bottom-right pane if (!xlWorksheet.SheetView.TopLeftCellAddress.IsValid || xlWorksheet.SheetView.TopLeftCellAddress == new XLAddress(1, 1, fixedRow: false, fixedColumn: false)) + { sheetView.TopLeftCell = null; + } else + { sheetView.TopLeftCell = xlWorksheet.SheetView.TopLeftCellAddress.ToString(); + } if (xlWorksheet.SelectedRanges.Any() || xlWorksheet.ActiveCell != null) { @@ -4798,29 +5522,37 @@ private static void GenerateWorksheetPartContent( var firstSelection = xlWorksheet.SelectedRanges.FirstOrDefault(); - Action populateSelection = (Selection selection) => + void populateSelection(Selection selection) { if (xlWorksheet.ActiveCell != null) + { selection.ActiveCell = xlWorksheet.ActiveCell.Address.ToStringRelative(false); + } else if (firstSelection != null) + { selection.ActiveCell = firstSelection.RangeAddress.FirstAddress.ToStringRelative(false); + } - var seqRef = new List { selection.ActiveCell.Value }; + var seqRef = new List { selection.ActiveCell.Value }; seqRef.AddRange(xlWorksheet.SelectedRanges .Select(range => { if (range.RangeAddress.FirstAddress.Equals(range.RangeAddress.LastAddress)) + { return range.RangeAddress.FirstAddress.ToStringRelative(false); + } else + { return range.RangeAddress.ToStringRelative(false); + } }) ); - selection.SequenceOfReferences = new ListValue { InnerText = String.Join(" ", seqRef.Distinct().ToArray()) }; + selection.SequenceOfReferences = new ListValue { InnerText = string.Join(" ", seqRef.Distinct().ToArray()) }; sheetView.InsertAfter(selection, svcm.GetPreviousElementFor(XLSheetViewContents.Selection)); svcm.SetElement(XLSheetViewContents.Selection, selection); - }; + } // If a pane exists, we need to set the active pane too // Yes, this might lead to 2 Selection elements! @@ -4835,39 +5567,61 @@ private static void GenerateWorksheetPartContent( } if (xlWorksheet.SheetView.ZoomScale == 100) + { sheetView.ZoomScale = null; + } else - sheetView.ZoomScale = (UInt32)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScale)); + { + sheetView.ZoomScale = (uint)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScale)); + } if (xlWorksheet.SheetView.ZoomScaleNormal == 100) + { sheetView.ZoomScaleNormal = null; + } else - sheetView.ZoomScaleNormal = (UInt32)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScaleNormal)); + { + sheetView.ZoomScaleNormal = (uint)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScaleNormal)); + } if (xlWorksheet.SheetView.ZoomScalePageLayoutView == 100) + { sheetView.ZoomScalePageLayoutView = null; + } else - sheetView.ZoomScalePageLayoutView = (UInt32)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScalePageLayoutView)); + { + sheetView.ZoomScalePageLayoutView = (uint)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScalePageLayoutView)); + } if (xlWorksheet.SheetView.ZoomScaleSheetLayoutView == 100) + { sheetView.ZoomScaleSheetLayoutView = null; + } else - sheetView.ZoomScaleSheetLayoutView = (UInt32)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScaleSheetLayoutView)); + { + sheetView.ZoomScaleSheetLayoutView = (uint)Math.Max(10, Math.Min(400, xlWorksheet.SheetView.ZoomScaleSheetLayoutView)); + } #endregion SheetViews var maxOutlineColumn = 0; if (xlWorksheet.ColumnCount() > 0) + { maxOutlineColumn = xlWorksheet.GetMaxColumnOutline(); + } var maxOutlineRow = 0; if (xlWorksheet.RowCount() > 0) + { maxOutlineRow = xlWorksheet.GetMaxRowOutline(); + } #region SheetFormatProperties if (worksheetPart.Worksheet.SheetFormatProperties == null) + { worksheetPart.Worksheet.SheetFormatProperties = new SheetFormatProperties(); + } cm.SetElement(XLWorksheetContents.SheetFormatProperties, worksheetPart.Worksheet.SheetFormatProperties); @@ -4875,25 +5629,41 @@ private static void GenerateWorksheetPartContent( worksheetPart.Worksheet.SheetFormatProperties.DefaultRowHeight = xlWorksheet.RowHeight.SaveRound(); if (xlWorksheet.RowHeightChanged) + { worksheetPart.Worksheet.SheetFormatProperties.CustomHeight = true; + } else + { worksheetPart.Worksheet.SheetFormatProperties.CustomHeight = null; + } var worksheetColumnWidth = GetColumnWidth(xlWorksheet.ColumnWidth).SaveRound(); if (xlWorksheet.ColumnWidthChanged) + { worksheetPart.Worksheet.SheetFormatProperties.DefaultColumnWidth = worksheetColumnWidth; + } else + { worksheetPart.Worksheet.SheetFormatProperties.DefaultColumnWidth = null; + } if (maxOutlineColumn > 0) + { worksheetPart.Worksheet.SheetFormatProperties.OutlineLevelColumn = (byte)maxOutlineColumn; + } else + { worksheetPart.Worksheet.SheetFormatProperties.OutlineLevelColumn = null; + } if (maxOutlineRow > 0) + { worksheetPart.Worksheet.SheetFormatProperties.OutlineLevelRow = (byte)maxOutlineRow; + } else + { worksheetPart.Worksheet.SheetFormatProperties.OutlineLevelRow = null; + } #endregion SheetFormatProperties @@ -4903,7 +5673,9 @@ private static void GenerateWorksheetPartContent( if (xlWorksheet.Internals.CellsCollection.Count == 0 && xlWorksheet.Internals.ColumnsCollection.Count == 0 && worksheetStyleId == 0) + { worksheetPart.Worksheet.RemoveAllChildren(); + } else { if (!worksheetPart.Worksheet.Elements().Any()) @@ -4918,8 +5690,8 @@ private static void GenerateWorksheetPartContent( var sheetColumnsByMin = columns.Elements().ToDictionary(c => c.Min.Value, c => c); //Dictionary sheetColumnsByMax = columns.Elements().ToDictionary(c => c.Max.Value, c => c); - Int32 minInColumnsCollection; - Int32 maxInColumnsCollection; + int minInColumnsCollection; + int maxInColumnsCollection; if (xlWorksheet.Internals.ColumnsCollection.Count > 0) { minInColumnsCollection = xlWorksheet.Internals.ColumnsCollection.Keys.Min(); @@ -4934,7 +5706,7 @@ private static void GenerateWorksheetPartContent( if (minInColumnsCollection > 1) { UInt32Value min = 1; - UInt32Value max = (UInt32)(minInColumnsCollection - 1); + UInt32Value max = (uint)(minInColumnsCollection - 1); for (var co = min; co <= max; co++) { @@ -4953,12 +5725,12 @@ private static void GenerateWorksheetPartContent( for (var co = minInColumnsCollection; co <= maxInColumnsCollection; co++) { - UInt32 styleId; - Double columnWidth; + uint styleId; + double columnWidth; var isHidden = false; var collapsed = false; var outlineLevel = 0; - if (xlWorksheet.Internals.ColumnsCollection.TryGetValue(co, out XLColumn col)) + if (xlWorksheet.Internals.ColumnsCollection.TryGetValue(co, out var col)) { styleId = context.SharedStyles[col.StyleValue].StyleId; columnWidth = GetColumnWidth(col.Width).SaveRound(); @@ -4974,19 +5746,27 @@ private static void GenerateWorksheetPartContent( var column = new Column { - Min = (UInt32)co, - Max = (UInt32)co, + Min = (uint)co, + Max = (uint)co, Style = styleId, Width = columnWidth, CustomWidth = true }; if (isHidden) + { column.Hidden = true; + } + if (collapsed) + { column.Collapsed = true; + } + if (outlineLevel > 0) + { column.OutlineLevel = (byte)outlineLevel; + } UpdateColumn(column, columns, sheetColumnsByMin); //, sheetColumnsByMax); } @@ -4994,23 +5774,25 @@ private static void GenerateWorksheetPartContent( var collection = maxInColumnsCollection; foreach ( var col in - columns.Elements().Where(c => c.Min > (UInt32)(collection)).OrderBy( + columns.Elements().Where(c => c.Min > (uint)collection).OrderBy( c => c.Min.Value)) { col.Style = worksheetStyleId; col.Width = worksheetColumnWidth; col.CustomWidth = true; - if ((Int32)col.Max.Value > maxInColumnsCollection) - maxInColumnsCollection = (Int32)col.Max.Value; + if ((int)col.Max.Value > maxInColumnsCollection) + { + maxInColumnsCollection = (int)col.Max.Value; + } } if (maxInColumnsCollection < XLHelper.MaxColumnNumber && worksheetStyleId != 0) { var column = new Column { - Min = (UInt32)(maxInColumnsCollection + 1), - Max = (UInt32)(XLHelper.MaxColumnNumber), + Min = (uint)(maxInColumnsCollection + 1), + Max = XLHelper.MaxColumnNumber, Style = worksheetStyleId, Width = worksheetColumnWidth, CustomWidth = true @@ -5042,7 +5824,7 @@ var col in var lastRow = 0; var existingSheetDataRows = - sheetData.Elements().ToDictionary(r => r.RowIndex == null ? ++lastRow : (Int32)r.RowIndex.Value, + sheetData.Elements().ToDictionary(r => r.RowIndex == null ? ++lastRow : (int)r.RowIndex.Value, r => r); foreach ( var r in @@ -5066,10 +5848,14 @@ var r in { Row row; if (!existingSheetDataRows.TryGetValue(distinctRow, out row)) - row = new Row { RowIndex = (UInt32)distinctRow }; + { + row = new Row { RowIndex = (uint)distinctRow }; + } if (maxColumn > 0) + { row.Spans = new ListValue { InnerText = "1:" + maxColumn.ToInvariantString() }; + } row.Height = null; row.CustomHeight = null; @@ -5077,7 +5863,7 @@ var r in row.StyleIndex = null; row.CustomFormat = null; row.Collapsed = null; - if (xlWorksheet.Internals.RowsCollection.TryGetValue(distinctRow, out XLRow thisRow)) + if (xlWorksheet.Internals.RowsCollection.TryGetValue(distinctRow, out var thisRow)) { if (thisRow.HeightChanged) { @@ -5093,11 +5879,19 @@ var r in } if (thisRow.IsHidden) + { row.Hidden = true; + } + if (thisRow.Collapsed) + { row.Collapsed = true; + } + if (thisRow.OutlineLevel > 0) + { row.OutlineLevel = (byte)thisRow.OutlineLevel; + } } var lastCell = 0; @@ -5108,23 +5902,27 @@ var r in c => c ); - if (xlWorksheet.Internals.CellsCollection.Deleted.TryGetValue(distinctRow, out HashSet deletedColumns)) + if (xlWorksheet.Internals.CellsCollection.Deleted.TryGetValue(distinctRow, out var deletedColumns)) { foreach (var deletedColumn in deletedColumns.ToList()) { var key = XLHelper.GetColumnLetterFromNumber(deletedColumn) + distinctRow.ToInvariantString(); - if (!currentOpenXmlRowCells.TryGetValue(key, out Cell cell)) + if (!currentOpenXmlRowCells.TryGetValue(key, out var cell)) + { continue; + } row.RemoveChild(cell); deletedColumns.Remove(deletedColumn); } if (deletedColumns.Count == 0) + { xlWorksheet.Internals.CellsCollection.Deleted.Remove(distinctRow); + } } - if (xlWorksheet.Internals.CellsCollection.RowsCollection.TryGetValue(distinctRow, out Dictionary cells)) + if (xlWorksheet.Internals.CellsCollection.RowsCollection.TryGetValue(distinctRow, out var cells)) { var isNewRow = !row.Elements().Any(); lastCell = 0; @@ -5137,7 +5935,7 @@ var r in XLTableField field = null; var styleId = context.SharedStyles[xlCell.StyleValue].StyleId; - var cellReference = (xlCell.Address).GetTrimmedAddress(); + var cellReference = xlCell.Address.GetTrimmedAddress(); // For saving cells to file, ignore conditional formatting, data validation rules and merged // ranges. They just bloat the file @@ -5146,7 +5944,7 @@ var r in & ~XLCellsUsedOptions.DataValidation & ~XLCellsUsedOptions.MergedRanges); - if (currentOpenXmlRowCells.TryGetValue(cellReference, out Cell cell)) + if (currentOpenXmlRowCells.TryGetValue(cellReference, out var cell)) { if (isEmpty) { @@ -5162,26 +5960,34 @@ var r in { if (cell == null) { - cell = new Cell(); - cell.CellReference = new StringValue(cellReference); + cell = new Cell + { + CellReference = new StringValue(cellReference) + }; if (isNewRow) + { row.AppendChild(cell); + } else { var newColumn = XLHelper.GetColumnNumberFromAddress(cellReference); Cell cellBeforeInsert = null; - int[] lastCo = { Int32.MaxValue }; + int[] lastCo = { int.MaxValue }; foreach (var c in mRows.Where(kp => kp.Key > newColumn).Where(c => lastCo[0] > c.Key)) { cellBeforeInsert = c.Value; lastCo[0] = c.Key; } if (cellBeforeInsert == null) + { row.AppendChild(cell); + } else + { row.InsertBefore(cell, cellBeforeInsert); + } } } @@ -5195,7 +6001,9 @@ var r in var f = new CellFormula { FormulaType = CellFormulaValues.Array }; if (xlCell.FormulaReference == null) + { xlCell.FormulaReference = xlCell.AsRange().RangeAddress; + } if (xlCell.FormulaReference.FirstAddress.Equals(xlCell.Address)) { @@ -5207,21 +6015,35 @@ var r in } else { - cell.CellFormula = new CellFormula(); - cell.CellFormula.Text = formula; + cell.CellFormula = new CellFormula + { + Text = formula + }; } if (!options.EvaluateFormulasBeforeSaving || xlCell.CachedValue == null || xlCell.NeedsRecalculation) + { cell.CellValue = null; + } else { string valueCalculated; if (xlCell.CachedValue is int) + { valueCalculated = ((int)xlCell.CachedValue).ToInvariantString(); + } else if (xlCell.CachedValue is double) + { valueCalculated = ((double)xlCell.CachedValue).ToInvariantString(); + } + else if (xlCell.CachedValue is bool) + { + valueCalculated = ((bool)xlCell.CachedValue).ToInvariantString().ToLowerInvariant(); + } else + { valueCalculated = xlCell.CachedValue.ToString(); + } cell.CellValue = new CellValue(valueCalculated); } @@ -5231,9 +6053,9 @@ var r in var table = xlWorksheet.Tables.First(t => t.AsRange().Contains(xlCell)); field = table.Fields.First(f => f.Column.ColumnNumber() == xlCell.Address.ColumnNumber) as XLTableField; - if (!String.IsNullOrWhiteSpace(field.TotalsRowLabel)) + if (!string.IsNullOrWhiteSpace(field.TotalsRowLabel)) { - cell.DataType = XLWorkbook.CvSharedString; + cell.DataType = CvSharedString; } else { @@ -5248,7 +6070,9 @@ var r in } if (options.EvaluateFormulasBeforeSaving || field != null || !xlCell.HasFormula) + { SetCellValue(xlCell, field, cell, context); + } } } xlWorksheet.Internals.CellsCollection.Deleted.Remove(distinctRow); @@ -5277,12 +6101,14 @@ var r in { if (existingSheetDataRows.Any(r => r.Key > row.RowIndex.Value)) { - var minRow = existingSheetDataRows.Where(r => r.Key > (Int32)row.RowIndex.Value).Min(r => r.Key); + var minRow = existingSheetDataRows.Where(r => r.Key > (int)row.RowIndex.Value).Min(r => r.Key); var rowBeforeInsert = existingSheetDataRows[minRow]; sheetData.InsertBefore(row, rowBeforeInsert); } else + { sheetData.AppendChild(row); + } } } } @@ -5290,7 +6116,7 @@ var r in foreach (var r in xlWorksheet.Internals.CellsCollection.Deleted.Keys) { - if (existingSheetDataRows.TryGetValue(r, out Row row)) + if (existingSheetDataRows.TryGetValue(r, out var row)) { sheetData.RemoveChild(row); existingSheetDataRows.Remove(r); @@ -5323,8 +6149,10 @@ var r in if (protection.Algorithm == XLProtectionAlgorithm.Algorithm.SimpleHash) { - if (!String.IsNullOrWhiteSpace(protection.PasswordHash)) + if (!string.IsNullOrWhiteSpace(protection.PasswordHash)) + { sheetProtection.Password = protection.PasswordHash; + } } else { @@ -5383,7 +6211,7 @@ var r in #region MergeCells - if ((xlWorksheet).Internals.MergedRanges.Any()) + if (xlWorksheet.Internals.MergedRanges.Any()) { if (!worksheetPart.Worksheet.Elements().Any()) { @@ -5395,12 +6223,14 @@ var r in cm.SetElement(XLWorksheetContents.MergeCells, mergeCells); mergeCells.RemoveAllChildren(); - foreach (var mergeCell in (xlWorksheet).Internals.MergedRanges.Select( + foreach (var mergeCell in xlWorksheet.Internals.MergedRanges.Select( m => m.RangeAddress.FirstAddress.ToString() + ":" + m.RangeAddress.LastAddress.ToString()).Select( merged => new MergeCell { Reference = merged })) + { mergeCells.AppendChild(mergeCell); + } - mergeCells.Count = (UInt32)mergeCells.Count(); + mergeCells.Count = (uint)mergeCells.Count(); } else { @@ -5454,20 +6284,20 @@ var r in if (!worksheetPart.Worksheet.Elements().Any()) { var previousElement = cm.GetPreviousElementFor(XLWorksheetContents.WorksheetExtensionList); - worksheetPart.Worksheet.InsertAfter(new WorksheetExtensionList(), previousElement); + worksheetPart.Worksheet.InsertAfter(new WorksheetExtensionList(), previousElement); } - WorksheetExtensionList worksheetExtensionList = worksheetPart.Worksheet.Elements().First(); + var worksheetExtensionList = worksheetPart.Worksheet.Elements().First(); cm.SetElement(XLWorksheetContents.WorksheetExtensionList, worksheetExtensionList); - var conditionalFormattings = worksheetExtensionList.Descendants().SingleOrDefault(); + var conditionalFormattings = worksheetExtensionList.Descendants().SingleOrDefault(); if (conditionalFormattings == null || !conditionalFormattings.Any()) { - WorksheetExtension worksheetExtension1 = new WorksheetExtension { Uri = "{78C0D931-6437-407d-A8EE-F0AAD7539E65}" }; + var worksheetExtension1 = new WorksheetExtension { Uri = "{78C0D931-6437-407d-A8EE-F0AAD7539E65}" }; worksheetExtension1.AddNamespaceDeclaration("x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"); worksheetExtensionList.Append(worksheetExtension1); - conditionalFormattings = new DocumentFormat.OpenXml.Office2010.Excel.ConditionalFormattings(); + conditionalFormattings = new X14.ConditionalFormattings(); worksheetExtension1.Append(conditionalFormattings); } @@ -5475,24 +6305,24 @@ var r in .GroupBy( c => string.Join(" ", c.Ranges.Select(r => r.RangeAddress.ToStringRelative(false))), c => c, - (key, g) => new { RangeId = key, CfList = g.ToList() } + (key, g) => new { RangeId = key, CfList = g.ToList() } ) ) { foreach (var xlConditionalFormat in cfGroup.CfList.Cast()) { - var conditionalFormattingRule = conditionalFormattings.Descendants() + var conditionalFormattingRule = conditionalFormattings.Descendants() .SingleOrDefault(r => r.Id == xlConditionalFormat.Id.WrapInBraces()); if (conditionalFormattingRule != null) { - var conditionalFormat = conditionalFormattingRule.Ancestors().SingleOrDefault(); - conditionalFormattings.RemoveChild(conditionalFormat); + var conditionalFormat = conditionalFormattingRule.Ancestors().SingleOrDefault(); + conditionalFormattings.RemoveChild(conditionalFormat); } - var conditionalFormatting = new DocumentFormat.OpenXml.Office2010.Excel.ConditionalFormatting(); + var conditionalFormatting = new X14.ConditionalFormatting(); conditionalFormatting.AddNamespaceDeclaration("xm", "http://schemas.microsoft.com/office/excel/2006/main"); conditionalFormatting.Append(XLCFConvertersExtension.Convert(xlConditionalFormat, context)); - var referenceSequence = new DocumentFormat.OpenXml.Office.Excel.ReferenceSequence { Text = cfGroup.RangeId }; + var referenceSequence = new OfficeExcel.ReferenceSequence { Text = cfGroup.RangeId }; conditionalFormatting.Append(referenceSequence); conditionalFormattings.Append(conditionalFormatting); @@ -5560,7 +6390,9 @@ var r in { // Do not create an empty Sparkline group if (!xlSparklineGroup.Any()) + { continue; + } var sparklineGroup = new X14.SparklineGroup(); sparklineGroup.SetAttribute(new OpenXmlAttribute("xr2", "uid", "http://schemas.microsoft.com/office/spreadsheetml/2015/revision2", "{A98FF5F8-AE60-43B5-8001-AD89004F45D3}")); @@ -5590,16 +6422,22 @@ var r in sparklineGroup.RightToLeft = xlSparklineGroup.HorizontalAxis.RightToLeft; sparklineGroup.DateAxis = xlSparklineGroup.HorizontalAxis.DateAxis; if (xlSparklineGroup.HorizontalAxis.DateAxis) + { sparklineGroup.Formula = new OfficeExcel.Formula( xlSparklineGroup.DateRange.RangeAddress.ToString(XLReferenceStyle.A1, true)); + } sparklineGroup.MinAxisType = xlSparklineGroup.VerticalAxis.MinAxisType.ToOpenXml(); if (xlSparklineGroup.VerticalAxis.MinAxisType == XLSparklineAxisMinMax.Custom) + { sparklineGroup.ManualMin = xlSparklineGroup.VerticalAxis.ManualMin; + } sparklineGroup.MaxAxisType = xlSparklineGroup.VerticalAxis.MaxAxisType.ToOpenXml(); if (xlSparklineGroup.VerticalAxis.MaxAxisType == XLSparklineAxisMinMax.Custom) + { sparklineGroup.ManualMax = xlSparklineGroup.VerticalAxis.ManualMax; + } var sparklines = new X14.Sparklines(xlSparklineGroup .Select(xlSparkline => new X14.Sparkline @@ -5649,10 +6487,12 @@ var r in foreach (var dv in xlWorksheet.DataValidations) { - var sequence = dv.Ranges.Aggregate(String.Empty, (current, r) => current + (r.RangeAddress + " ")); + var sequence = dv.Ranges.Aggregate(string.Empty, (current, r) => current + r.RangeAddress + " "); if (sequence.Length > 0) + { sequence = sequence.Substring(0, sequence.Length - 1); + } var dataValidation = new DataValidation { @@ -5675,7 +6515,7 @@ var r in dataValidations.AppendChild(dataValidation); } - dataValidations.Count = (UInt32)xlWorksheet.DataValidations.Count(); + dataValidations.Count = (uint)xlWorksheet.DataValidations.Count(); } #endregion DataValidations @@ -5718,8 +6558,11 @@ var r in Display = hl.Cell.GetFormattedString() }; } - if (!String.IsNullOrWhiteSpace(hl.Tooltip)) + if (!string.IsNullOrWhiteSpace(hl.Tooltip)) + { hyperlink.Tooltip = hl.Tooltip; + } + hyperlinks.AppendChild(hyperlink); } } @@ -5775,7 +6618,7 @@ var r in cm.SetElement(XLWorksheetContents.PageSetup, pageSetup); pageSetup.Orientation = xlWorksheet.PageSetup.PageOrientation.ToOpenXml(); - pageSetup.PaperSize = (UInt32)xlWorksheet.PageSetup.PaperSize; + pageSetup.PaperSize = (uint)xlWorksheet.PageSetup.PaperSize; pageSetup.BlackAndWhite = xlWorksheet.PageSetup.BlackAndWhite; pageSetup.Draft = xlWorksheet.PageSetup.DraftQuality; pageSetup.PageOrder = xlWorksheet.PageSetup.PageOrder.ToOpenXml(); @@ -5794,18 +6637,26 @@ var r in } if (xlWorksheet.PageSetup.HorizontalDpi > 0) - pageSetup.HorizontalDpi = (UInt32)xlWorksheet.PageSetup.HorizontalDpi; + { + pageSetup.HorizontalDpi = (uint)xlWorksheet.PageSetup.HorizontalDpi; + } else + { pageSetup.HorizontalDpi = null; + } if (xlWorksheet.PageSetup.VerticalDpi > 0) - pageSetup.VerticalDpi = (UInt32)xlWorksheet.PageSetup.VerticalDpi; + { + pageSetup.VerticalDpi = (uint)xlWorksheet.PageSetup.VerticalDpi; + } else + { pageSetup.VerticalDpi = null; + } if (xlWorksheet.PageSetup.Scale > 0) { - pageSetup.Scale = (UInt32)xlWorksheet.PageSetup.Scale; + pageSetup.Scale = (uint)xlWorksheet.PageSetup.Scale; pageSetup.FitToWidth = null; pageSetup.FitToHeight = null; } @@ -5814,17 +6665,23 @@ var r in pageSetup.Scale = null; if (xlWorksheet.PageSetup.PagesWide >= 0 && xlWorksheet.PageSetup.PagesWide != 1) - pageSetup.FitToWidth = (UInt32)xlWorksheet.PageSetup.PagesWide; + { + pageSetup.FitToWidth = (uint)xlWorksheet.PageSetup.PagesWide; + } if (xlWorksheet.PageSetup.PagesTall >= 0 && xlWorksheet.PageSetup.PagesTall != 1) - pageSetup.FitToHeight = (UInt32)xlWorksheet.PageSetup.PagesTall; + { + pageSetup.FitToHeight = (uint)xlWorksheet.PageSetup.PagesTall; + } } // For some reason some Excel files already contains pageSetup.Copies = 0 // The validation fails for this // Let's remove the attribute of that's the case. if ((pageSetup?.Copies ?? 0) <= 0) + { pageSetup.Copies = null; + } #endregion PageSetup @@ -5832,9 +6689,13 @@ var r in var headerFooter = worksheetPart.Worksheet.Elements().FirstOrDefault(); if (headerFooter == null) + { headerFooter = new HeaderFooter(); + } else + { worksheetPart.Worksheet.RemoveAllChildren(); + } { var previousElement = cm.GetPreviousElementFor(XLWorksheetContents.HeaderFooter); @@ -5896,16 +6757,19 @@ var r in var rowBreaksToAdd = xlWorksheet.PageSetup.RowBreaks .Where(xlRb => !existingBreaks.Any(rb => rb.Id.HasValue && rb.Id.Value == xlRb)); - rowBreaks.Count = (UInt32)rowBreakCount; - rowBreaks.ManualBreakCount = (UInt32)rowBreakCount; - var lastRowNum = (UInt32)xlWorksheet.RangeAddress.LastAddress.RowNumber; + rowBreaks.Count = (uint)rowBreakCount; + rowBreaks.ManualBreakCount = (uint)rowBreakCount; + var lastRowNum = (uint)xlWorksheet.RangeAddress.LastAddress.RowNumber; foreach (var break1 in rowBreaksToAdd.Select(rb => new Break { - Id = (UInt32)rb, + Id = (uint)rb, Max = lastRowNum, ManualPageBreak = true })) + { rowBreaks.AppendChild(break1); + } + cm.SetElement(XLWorksheetContents.RowBreaks, rowBreaks); } else @@ -5943,16 +6807,19 @@ var r in var columnBreaksToAdd = xlWorksheet.PageSetup.ColumnBreaks .Where(xlCb => !existingBreaks.Any(cb => cb.Id.HasValue && cb.Id.Value == xlCb)); - columnBreaks.Count = (UInt32)columnBreakCount; - columnBreaks.ManualBreakCount = (UInt32)columnBreakCount; - var maxColumnNumber = (UInt32)xlWorksheet.RangeAddress.LastAddress.ColumnNumber; + columnBreaks.Count = (uint)columnBreakCount; + columnBreaks.ManualBreakCount = (uint)columnBreakCount; + var maxColumnNumber = (uint)xlWorksheet.RangeAddress.LastAddress.ColumnNumber; foreach (var break1 in columnBreaksToAdd.Select(cb => new Break { - Id = (UInt32)cb, + Id = (uint)cb, Max = maxColumnNumber, ManualPageBreak = true })) + { columnBreaks.AppendChild(break1); + } + cm.SetElement(XLWorksheetContents.ColumnBreaks, columnBreaks); } else @@ -5977,6 +6844,15 @@ var r in foreach (var removedPicture in xlPictures.Deleted) { worksheetPart.DrawingsPart.DeletePart(removedPicture); + // Remove Image reference link + foreach (var wd in worksheetPart.DrawingsPart.WorksheetDrawing) + { + if (wd.Descendants().Any(x => x.Embed == removedPicture)) + { + worksheetPart.DrawingsPart.WorksheetDrawing.RemoveChild(wd); + break; + } + } } xlPictures.Deleted.Clear(); } @@ -5987,7 +6863,9 @@ var r in } if (xlWorksheet.Pictures.Any()) + { RebaseNonVisualDrawingPropertiesIds(worksheetPart); + } var tableParts = worksheetPart.Worksheet.Elements().First(); if (xlWorksheet.Pictures.Any() && !worksheetPart.Worksheet.OfType().Any()) @@ -5998,9 +6876,22 @@ var r in cm.SetElement(XLWorksheetContents.Drawing, worksheetPart.Worksheet.Elements().First()); } + bool isEmptyDrawingsPart(DrawingsPart drawingsPart) + { + return drawingsPart != null + && !drawingsPart.CustomXmlParts.Any() + && !drawingsPart.ImageParts.Any() + && !drawingsPart.DiagramStyleParts.Any() + && !drawingsPart.DiagramLayoutDefinitionParts.Any() + && !drawingsPart.DiagramPersistLayoutParts.Any() + && !drawingsPart.DiagramDataParts.Any() + && !drawingsPart.DiagramColorsParts.Any() + && !drawingsPart.ChartParts.Any() + && !drawingsPart.WebExtensionParts.Any(); + } + // Instead of saving a file with an empty Drawings.xml file, rather remove the .xml file - if (!xlWorksheet.Pictures.Any() && worksheetPart.DrawingsPart != null - && !worksheetPart.DrawingsPart.Parts.Any()) + if (!xlWorksheet.Pictures.Any() && isEmptyDrawingsPart(worksheetPart.DrawingsPart)) { var id = worksheetPart.GetIdOfPart(worksheetPart.DrawingsPart); worksheetPart.Worksheet.RemoveChild(worksheetPart.Worksheet.OfType().FirstOrDefault(p => p.Id == id)); @@ -6016,7 +6907,7 @@ var r in { worksheetPart.Worksheet.RemoveAllChildren(); - if (!String.IsNullOrWhiteSpace(xlWorksheet.LegacyDrawingId)) + if (!string.IsNullOrWhiteSpace(xlWorksheet.LegacyDrawingId)) { var previousElement = cm.GetPreviousElementFor(XLWorksheetContents.LegacyDrawing); worksheetPart.Worksheet.InsertAfter(new LegacyDrawing { Id = xlWorksheet.LegacyDrawingId }, @@ -6048,10 +6939,12 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml { if (field != null) { - if (!String.IsNullOrWhiteSpace(field.TotalsRowLabel)) + if (!string.IsNullOrWhiteSpace(field.TotalsRowLabel)) { - var cellValue = new CellValue(); - cellValue.Text = xlCell.SharedStringId.ToInvariantString(); + var cellValue = new CellValue + { + Text = xlCell.SharedStringId.ToInvariantString() + }; openXmlCell.DataType = CvSharedString; openXmlCell.CellValue = cellValue; } @@ -6073,7 +6966,7 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml cellValue.Text = v.ObjectToInvariantString(); switch (v) { - case String s: + case string s: openXmlCell.DataType = new EnumValue(CellValues.String); break; @@ -6081,15 +6974,20 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml openXmlCell.DataType = new EnumValue(CellValues.Date); break; - case Boolean b: + case bool b: openXmlCell.DataType = new EnumValue(CellValues.Boolean); break; default: if (v.IsNumber()) + { openXmlCell.DataType = new EnumValue(CellValues.Number); + } else + { openXmlCell.DataType = null; + } + break; } } @@ -6102,23 +7000,31 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml return; } else + { openXmlCell.CellValue = null; + } var dataType = xlCell.DataType; if (dataType != XLDataType.Text) + { openXmlCell.InlineString = null; + } if (dataType == XLDataType.Text) { if (!xlCell.StyleValue.IncludeQuotePrefix && xlCell.InnerText.Length == 0) + { openXmlCell.CellValue = null; + } else { if (xlCell.ShareString) { - var cellValue = new CellValue(); - cellValue.Text = xlCell.SharedStringId.ToInvariantString(); + var cellValue = new CellValue + { + Text = xlCell.SharedStringId.ToInvariantString() + }; openXmlCell.CellValue = cellValue; openXmlCell.InlineString = null; @@ -6135,7 +7041,9 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml var text = xlCell.GetString(); var t = new Text(text); if (text.PreserveSpaces()) + { t.Space = SpaceProcessingModeValues.Preserve; + } inlineString.Text = t; } @@ -6147,16 +7055,18 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml else if (dataType == XLDataType.TimeSpan) { var timeSpan = xlCell.GetTimeSpan(); - var cellValue = new CellValue(); - cellValue.Text = timeSpan.TotalDays.ToInvariantString(); + var cellValue = new CellValue + { + Text = timeSpan.TotalDays.ToInvariantString() + }; openXmlCell.CellValue = cellValue; } else if (dataType == XLDataType.DateTime || dataType == XLDataType.Number) { - if (!String.IsNullOrWhiteSpace(xlCell.InnerText)) + if (!string.IsNullOrWhiteSpace(xlCell.InnerText)) { var cellValue = new CellValue(); - var d = Double.Parse(xlCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture); + var d = double.Parse(xlCell.InnerText, XLHelper.NumberStyle, XLHelper.ParseCulture); if (xlCell.Worksheet.Workbook.Use1904DateSystem && xlCell.DataType == XLDataType.DateTime) { @@ -6171,8 +7081,10 @@ private static void SetCellValue(XLCell xlCell, XLTableField field, Cell openXml } else { - var cellValue = new CellValue(); - cellValue.Text = xlCell.InnerText; + var cellValue = new CellValue + { + Text = xlCell.InnerText + }; openXmlCell.CellValue = cellValue; } } @@ -6184,7 +7096,7 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut foreach (var kp in xlAutoFilter.Filters) { - var filterColumn = new FilterColumn { ColumnId = (UInt32)kp.Key - 1 }; + var filterColumn = new FilterColumn { ColumnId = (uint)kp.Key - 1 }; var xlFilterColumn = xlAutoFilter.Column(kp.Key); switch (xlFilterColumn.FilterType) @@ -6196,10 +7108,14 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut var customFilter = new CustomFilter { Val = filter.Value.ObjectToInvariantString() }; if (filter.Operator != XLFilterOperator.Equal) + { customFilter.Operator = filter.Operator.ToOpenXml(); + } if (filter.Connector == XLConnector.And) + { customFilters.And = true; + } customFilters.Append(customFilter); } @@ -6208,11 +7124,16 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut case XLFilterType.TopBottom: - var top101 = new Top10 { Val = (double)xlFilterColumn.TopBottomValue }; + var top101 = new Top10 { Val = xlFilterColumn.TopBottomValue }; if (xlFilterColumn.TopBottomType == XLTopBottomType.Percent) + { top101.Percent = true; + } + if (xlFilterColumn.TopBottomPart == XLTopBottomPart.Bottom) + { top101.Top = false; + } filterColumn.Append(top101); break; @@ -6233,15 +7154,34 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut var d = (DateTime)filter.Value; var dgi = new DateGroupItem { - Year = (UInt16)d.Year, + Year = (ushort)d.Year, DateTimeGrouping = filter.DateTimeGrouping.ToOpenXml() }; - if (filter.DateTimeGrouping >= XLDateTimeGrouping.Month) dgi.Month = (UInt16)d.Month; - if (filter.DateTimeGrouping >= XLDateTimeGrouping.Day) dgi.Day = (UInt16)d.Day; - if (filter.DateTimeGrouping >= XLDateTimeGrouping.Hour) dgi.Hour = (UInt16)d.Hour; - if (filter.DateTimeGrouping >= XLDateTimeGrouping.Minute) dgi.Minute = (UInt16)d.Minute; - if (filter.DateTimeGrouping >= XLDateTimeGrouping.Second) dgi.Second = (UInt16)d.Second; + if (filter.DateTimeGrouping >= XLDateTimeGrouping.Month) + { + dgi.Month = (ushort)d.Month; + } + + if (filter.DateTimeGrouping >= XLDateTimeGrouping.Day) + { + dgi.Day = (ushort)d.Day; + } + + if (filter.DateTimeGrouping >= XLDateTimeGrouping.Hour) + { + dgi.Hour = (ushort)d.Hour; + } + + if (filter.DateTimeGrouping >= XLDateTimeGrouping.Minute) + { + dgi.Minute = (ushort)d.Minute; + } + + if (filter.DateTimeGrouping >= XLDateTimeGrouping.Second) + { + dgi.Second = (ushort)d.Second; + } dateTimeGroupFilters.Append(dgi); } @@ -6264,12 +7204,15 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut if (xlAutoFilter.Sorted) { - string reference = null; - + string reference; if (filterRange.FirstCell().Address.RowNumber < filterRange.LastCell().Address.RowNumber) + { reference = filterRange.Range(filterRange.FirstCell().CellBelow(), filterRange.LastCell()).RangeAddress.ToString(); + } else + { reference = filterRange.RangeAddress.ToString(); + } var sortState = new SortState { @@ -6283,7 +7226,9 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut xlAutoFilter.SortColumn).RangeAddress.ToString() }; if (xlAutoFilter.SortOrder == XLSortOrder.Descending) + { sortCondition.Descending = true; + } sortState.Append(sortCondition); autoFilter.Append(sortState); @@ -6292,7 +7237,7 @@ private static void PopulateAutoFilter(XLAutoFilter xlAutoFilter, AutoFilter aut private static void CollapseColumns(Columns columns, Dictionary sheetColumns) { - UInt32 lastMin = 1; + uint lastMin = 1; var count = sheetColumns.Count; var arr = sheetColumns.OrderBy(kp => kp.Key).ToArray(); // sheetColumns[kp.Key + 1] @@ -6303,7 +7248,10 @@ private static void CollapseColumns(Columns columns, Dictionary sh for (var i = 0; i < count; i++) { var kp = arr[i]; - if (i + 1 != count && ColumnsAreEqual(kp.Value, arr[i + 1].Value)) continue; + if (i + 1 != count && ColumnsAreEqual(kp.Value, arr[i + 1].Value)) + { + continue; + } var newColumn = (Column)kp.Value.CloneNode(true); newColumn.Min = lastMin; @@ -6326,7 +7274,7 @@ private static double GetColumnWidth(double columnWidth) private static void UpdateColumn(Column column, Columns columns, Dictionary sheetColumnsByMin) { - if (!sheetColumnsByMin.TryGetValue(column.Min.Value, out Column newColumn)) + if (!sheetColumnsByMin.TryGetValue(column.Min.Value, out var newColumn)) { newColumn = (Column)column.CloneNode(true); columns.AppendChild(newColumn); @@ -6343,36 +7291,44 @@ private static void UpdateColumn(Column column, Columns columns, Dictionary 0) + { newColumn.OutlineLevel = (byte)column.OutlineLevel; + } else + { newColumn.OutlineLevel = null; + } sheetColumnsByMin.Remove(column.Min.Value); if (existingColumn.Min + 1 > existingColumn.Max) { - //existingColumn.Min = existingColumn.Min + 1; - //columns.InsertBefore(existingColumn, newColumn); - //existingColumn.Remove(); columns.RemoveChild(existingColumn); columns.AppendChild(newColumn); sheetColumnsByMin.Add(newColumn.Min.Value, newColumn); } else { - //columns.InsertBefore(existingColumn, newColumn); columns.AppendChild(newColumn); sheetColumnsByMin.Add(newColumn.Min.Value, newColumn); - existingColumn.Min = existingColumn.Min + 1; + existingColumn.Min++; sheetColumnsByMin.Add(existingColumn.Min.Value, existingColumn); } } @@ -6398,4 +7354,4 @@ private static bool ColumnsAreEqual(Column left, Column right) #endregion GenerateWorksheetPartContent } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/XLWorksheet.cs b/ClosedXML/Excel/XLWorksheet.cs index 04ec4cd0d..fa9b1c4fe 100644 --- a/ClosedXML/Excel/XLWorksheet.cs +++ b/ClosedXML/Excel/XLWorksheet.cs @@ -1,10 +1,13 @@ using ClosedXML.Excel.Caching; using ClosedXML.Excel.CalcEngine; using ClosedXML.Excel.Drawings; +using ClosedXML.Excel.Ranges; using ClosedXML.Excel.Ranges.Index; +using ClosedXML.Excel.Style; +using ClosedXML.Excel.Tables; +using SkiaSharp; using System; using System.Collections.Generic; -using System.Drawing; using System.IO; using System.Linq; using static ClosedXML.Excel.XLProtectionAlgorithm; @@ -15,19 +18,19 @@ internal class XLWorksheet : XLRangeBase, IXLWorksheet { #region Fields - private readonly Dictionary _columnOutlineCount = new Dictionary(); - private readonly Dictionary _rowOutlineCount = new Dictionary(); + private readonly Dictionary _columnOutlineCount = new Dictionary(); + private readonly Dictionary _rowOutlineCount = new Dictionary(); private readonly XLRangeFactory _rangeFactory; private readonly XLRangeRepository _rangeRepository; private readonly List _rangeIndices; - internal Int32 ZOrder = 1; - private String _name; - internal Int32 _position; + internal int ZOrder = 1; + private string _name; + internal int _position; - private Double _rowHeight; - private Boolean _tabActive; + private double _rowHeight; + private bool _tabActive; private XLSheetProtection _protection; - internal Boolean EventTrackingEnabled; + internal bool EventTrackingEnabled; /// /// Fake address to be used everywhere the invalid address is needed. @@ -38,7 +41,7 @@ internal class XLWorksheet : XLRangeBase, IXLWorksheet #region Constructor - public XLWorksheet(String sheetName, XLWorkbook workbook) + public XLWorksheet(string sheetName, XLWorkbook workbook) : base( new XLRangeAddress( new XLAddress(null, XLHelper.MinRowNumber, XLHelper.MinColumnNumber, false, false), @@ -95,29 +98,25 @@ public XLWorksheet(String sheetName, XLWorkbook workbook) #endregion Constructor - public override XLRangeType RangeType - { - get { return XLRangeType.Worksheet; } - } + public override XLRangeType RangeType => XLRangeType.Worksheet; public string LegacyDrawingId; - public Boolean LegacyDrawingIsNew; - private Double _columnWidth; + public bool LegacyDrawingIsNew; + private double _columnWidth; public XLWorksheetInternals Internals { get; private set; } - public XLRangeFactory RangeFactory - { - get { return _rangeFactory; } - } + public XLRangeFactory RangeFactory => _rangeFactory; public override IEnumerable Styles { get { yield return GetStyle(); - foreach (XLCell c in Internals.CellsCollection.GetCells()) + foreach (var c in Internals.CellsCollection.GetCells()) + { yield return c.Style; + } } } @@ -131,7 +130,9 @@ protected override IEnumerable Children .OrderBy(c => c) .ToList(); foreach (var col in columnsUsed) + { yield return Column(col); + } var rowsUsed = Internals.RowsCollection.Keys .Union(Internals.CellsCollection.RowsUsed.Keys) @@ -139,17 +140,19 @@ protected override IEnumerable Children .OrderBy(r => r) .ToList(); foreach (var row in rowsUsed) + { yield return Row(row); + } } } - internal Boolean RowHeightChanged { get; set; } + internal bool RowHeightChanged { get; set; } - internal Boolean ColumnWidthChanged { get; set; } + internal bool ColumnWidthChanged { get; set; } - public Int32 SheetId { get; set; } + public int SheetId { get; set; } - internal String RelId { get; set; } + internal string RelId { get; set; } public XLDataValidations DataValidations { get; private set; } @@ -172,7 +175,7 @@ public XLSheetProtection Protection public XLWorkbook Workbook { get; private set; } - public Double ColumnWidth + public double ColumnWidth { get { return _columnWidth; } set @@ -182,7 +185,7 @@ public Double ColumnWidth } } - public Double RowHeight + public double RowHeight { get { return _rowHeight; } set @@ -192,12 +195,15 @@ public Double RowHeight } } - public String Name + public string Name { get { return _name; } set { - if (_name == value) return; + if (_name == value) + { + return; + } XLHelper.ValidateSheetName(value); @@ -206,13 +212,15 @@ public String Name } } - public Int32 Position + public int Position { get { return _position; } set { if (value > Workbook.WorksheetsInternal.Count + Workbook.UnsupportedSheets.Count + 1) + { throw new ArgumentOutOfRangeException(nameof(value), "Index must be equal or less than the number of worksheets + 1."); + } if (value < _position) { @@ -225,7 +233,7 @@ public Int32 Position { Workbook.WorksheetsInternal .Where(w => w.Position <= value && w.Position > _position) - .ForEach(w => (w)._position -= 1); + .ForEach(w => w._position -= 1); } _position = value; @@ -242,7 +250,7 @@ IXLRow IXLWorksheet.FirstRowUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRow IXLWorksheet.FirstRowUsed(Boolean includeFormats) + IXLRow IXLWorksheet.FirstRowUsed(bool includeFormats) { return FirstRowUsed(includeFormats ? XLCellsUsedOptions.All @@ -260,7 +268,7 @@ IXLRow IXLWorksheet.LastRowUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLRow IXLWorksheet.LastRowUsed(Boolean includeFormats) + IXLRow IXLWorksheet.LastRowUsed(bool includeFormats) { return LastRowUsed(includeFormats ? XLCellsUsedOptions.All @@ -298,7 +306,7 @@ IXLColumn IXLWorksheet.FirstColumnUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLColumn IXLWorksheet.FirstColumnUsed(Boolean includeFormats) + IXLColumn IXLWorksheet.FirstColumnUsed(bool includeFormats) { return FirstColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -316,7 +324,7 @@ IXLColumn IXLWorksheet.LastColumnUsed() } [Obsolete("Use the overload with XLCellsUsedOptions")] - IXLColumn IXLWorksheet.LastColumnUsed(Boolean includeFormats) + IXLColumn IXLWorksheet.LastColumnUsed(bool includeFormats) { return LastColumnUsed(includeFormats ? XLCellsUsedOptions.All @@ -330,7 +338,7 @@ IXLColumn IXLWorksheet.LastColumnUsed(XLCellsUsedOptions options) public IXLColumns Columns() { - var columnMap = new HashSet(); + var columnMap = new HashSet(); columnMap.UnionWith(Internals.CellsCollection.ColumnsUsed.Keys); columnMap.UnionWith(Internals.ColumnsCollection.Keys); @@ -339,14 +347,14 @@ public IXLColumns Columns() return retVal; } - public IXLColumns Columns(String columns) + public IXLColumns Columns(string columns) { var retVal = new XLColumns(null, StyleValue); var columnPairs = columns.Split(','); - foreach (string tPair in columnPairs.Select(pair => pair.Trim())) + foreach (var tPair in columnPairs.Select(pair => pair.Trim())) { - String firstColumn; - String lastColumn; + string firstColumn; + string lastColumn; if (tPair.Contains(':') || tPair.Contains('-')) { var columnRange = XLHelper.SplitRange(tPair); @@ -359,38 +367,45 @@ public IXLColumns Columns(String columns) lastColumn = tPair; } - if (Int32.TryParse(firstColumn, out int tmp)) + if (int.TryParse(firstColumn, out var tmp)) { - foreach (IXLColumn col in Columns(Int32.Parse(firstColumn), Int32.Parse(lastColumn))) + foreach (var col in Columns(int.Parse(firstColumn), int.Parse(lastColumn))) + { retVal.Add((XLColumn)col); + } } else { - foreach (IXLColumn col in Columns(firstColumn, lastColumn)) + foreach (var col in Columns(firstColumn, lastColumn)) + { retVal.Add((XLColumn)col); + } } } return retVal; } - public IXLColumns Columns(String firstColumn, String lastColumn) + public IXLColumns Columns(string firstColumn, string lastColumn) { return Columns(XLHelper.GetColumnNumberFromLetter(firstColumn), XLHelper.GetColumnNumberFromLetter(lastColumn)); } - public IXLColumns Columns(Int32 firstColumn, Int32 lastColumn) + public IXLColumns Columns(int firstColumn, int lastColumn) { var retVal = new XLColumns(null, StyleValue); - for (int co = firstColumn; co <= lastColumn; co++) + for (var co = firstColumn; co <= lastColumn; co++) + { retVal.Add(Column(co)); + } + return retVal; } public IXLRows Rows() { - var rowMap = new HashSet(); + var rowMap = new HashSet(); rowMap.UnionWith(Internals.CellsCollection.RowsUsed.Keys); rowMap.UnionWith(Internals.RowsCollection.Keys); @@ -399,14 +414,14 @@ public IXLRows Rows() return retVal; } - public IXLRows Rows(String rows) + public IXLRows Rows(string rows) { var retVal = new XLRows(null, StyleValue); var rowPairs = rows.Split(','); - foreach (string tPair in rowPairs.Select(pair => pair.Trim())) + foreach (var tPair in rowPairs.Select(pair => pair.Trim())) { - String firstRow; - String lastRow; + string firstRow; + string lastRow; if (tPair.Contains(':') || tPair.Contains('-')) { var rowRange = XLHelper.SplitRange(tPair); @@ -419,32 +434,35 @@ public IXLRows Rows(String rows) lastRow = tPair; } - Rows(Int32.Parse(firstRow), Int32.Parse(lastRow)) + Rows(int.Parse(firstRow), int.Parse(lastRow)) .ForEach(row => retVal.Add((XLRow)row)); } return retVal; } - public IXLRows Rows(Int32 firstRow, Int32 lastRow) + public IXLRows Rows(int firstRow, int lastRow) { var retVal = new XLRows(null, StyleValue); - for (int ro = firstRow; ro <= lastRow; ro++) + for (var ro = firstRow; ro <= lastRow; ro++) + { retVal.Add(Row(ro)); + } + return retVal; } - IXLRow IXLWorksheet.Row(Int32 row) + IXLRow IXLWorksheet.Row(int row) { return Row(row); } - IXLColumn IXLWorksheet.Column(Int32 column) + IXLColumn IXLWorksheet.Column(int column) { return Column(column); } - IXLColumn IXLWorksheet.Column(String column) + IXLColumn IXLWorksheet.Column(string column) { return Column(column); } @@ -523,37 +541,45 @@ public IXLWorksheet ExpandColumns() return this; } - public IXLWorksheet CollapseRows(Int32 outlineLevel) + public IXLWorksheet CollapseRows(int outlineLevel) { if (outlineLevel < 1 || outlineLevel > 8) + { throw new ArgumentOutOfRangeException("outlineLevel", "Outline level must be between 1 and 8."); + } Internals.RowsCollection.Values.Where(r => r.OutlineLevel == outlineLevel).ForEach(r => r.Collapse()); return this; } - public IXLWorksheet CollapseColumns(Int32 outlineLevel) + public IXLWorksheet CollapseColumns(int outlineLevel) { if (outlineLevel < 1 || outlineLevel > 8) + { throw new ArgumentOutOfRangeException("outlineLevel", "Outline level must be between 1 and 8."); + } Internals.ColumnsCollection.Values.Where(c => c.OutlineLevel == outlineLevel).ForEach(c => c.Collapse()); return this; } - public IXLWorksheet ExpandRows(Int32 outlineLevel) + public IXLWorksheet ExpandRows(int outlineLevel) { if (outlineLevel < 1 || outlineLevel > 8) + { throw new ArgumentOutOfRangeException("outlineLevel", "Outline level must be between 1 and 8."); + } Internals.RowsCollection.Values.Where(r => r.OutlineLevel == outlineLevel).ForEach(r => r.Expand()); return this; } - public IXLWorksheet ExpandColumns(Int32 outlineLevel) + public IXLWorksheet ExpandColumns(int outlineLevel) { if (outlineLevel < 1 || outlineLevel > 8) + { throw new ArgumentOutOfRangeException("outlineLevel", "Outline level must be between 1 and 8."); + } Internals.ColumnsCollection.Values.Where(c => c.OutlineLevel == outlineLevel).ForEach(c => c.Expand()); return this; @@ -568,33 +594,33 @@ public void Delete() public IXLNamedRanges NamedRanges { get; private set; } - public IXLNamedRange NamedRange(String rangeName) + public IXLNamedRange NamedRange(string rangeName) { return NamedRanges.NamedRange(rangeName); } - IXLSheetView IXLWorksheet.SheetView { get => SheetView; } + IXLSheetView IXLWorksheet.SheetView => SheetView; public XLSheetView SheetView { get; private set; } public IXLTables Tables { get; private set; } - public IXLTable Table(Int32 index) + public IXLTable Table(int index) { return Tables.Table(index); } - public IXLTable Table(String name) + public IXLTable Table(string name) { return Tables.Table(name); } - public IXLWorksheet CopyTo(String newSheetName) + public IXLWorksheet CopyTo(string newSheetName) { return CopyTo(Workbook, newSheetName, Workbook.WorksheetsInternal.Count + 1); } - public IXLWorksheet CopyTo(String newSheetName, Int32 position) + public IXLWorksheet CopyTo(string newSheetName, int position) { return CopyTo(Workbook, newSheetName, position); } @@ -604,15 +630,17 @@ public IXLWorksheet CopyTo(XLWorkbook workbook) return CopyTo(workbook, Name, workbook.WorksheetsInternal.Count + 1); } - public IXLWorksheet CopyTo(XLWorkbook workbook, String newSheetName) + public IXLWorksheet CopyTo(XLWorkbook workbook, string newSheetName) { return CopyTo(workbook, newSheetName, workbook.WorksheetsInternal.Count + 1); } - public IXLWorksheet CopyTo(XLWorkbook workbook, String newSheetName, Int32 position) + public IXLWorksheet CopyTo(XLWorkbook workbook, string newSheetName, int position) { - if (this.IsDeleted) - throw new InvalidOperationException($"`{this.Name}` has been deleted and cannot be copied."); + if (IsDeleted) + { + throw new InvalidOperationException($"`{Name}` has been deleted and cannot be copied."); + } var targetSheet = (XLWorksheet)workbook.WorksheetsInternal.Add(newSheetName, position); Internals.ColumnsCollection.ForEach(kp => kp.Value.CopyTo(targetSheet.Column(kp.Key))); @@ -652,10 +680,7 @@ public IXLWorksheet CopyTo(XLWorkbook workbook, String newSheetName, Int32 posit public new IXLHyperlinks Hyperlinks { get; private set; } - IXLDataValidations IXLWorksheet.DataValidations - { - get { return DataValidations; } - } + IXLDataValidations IXLWorksheet.DataValidations => DataValidations; private XLWorksheetVisibility _visibility; @@ -665,7 +690,9 @@ public XLWorksheetVisibility Visibility set { if (value != XLWorksheetVisibility.Visible) + { TabSelected = false; + } _visibility = value; } @@ -694,12 +721,12 @@ public IXLSheetProtection Protect() return Protection.Protect(); } - public IXLSheetProtection Protect(String password, Algorithm algorithm = DefaultProtectionAlgorithm) + public IXLSheetProtection Protect(string password, Algorithm algorithm = DefaultProtectionAlgorithm) { return Protection.Protect(password, algorithm, XLSheetProtectionElements.SelectEverything); } - public IXLSheetProtection Protect(String password, Algorithm algorithm, XLSheetProtectionElements allowedElements) + public IXLSheetProtection Protect(string password, Algorithm algorithm, XLSheetProtectionElements allowedElements) { return Protection.Protect(password, algorithm, allowedElements); } @@ -709,7 +736,7 @@ IXLElementProtection IXLProtectable.Protect() return Protect(); } - IXLElementProtection IXLProtectable.Protect(String password, Algorithm algorithm) + IXLElementProtection IXLProtectable.Protect(string password, Algorithm algorithm) { return Protect(password, algorithm); } @@ -719,7 +746,7 @@ public IXLSheetProtection Unprotect() return Protection.Unprotect(); } - public IXLSheetProtection Unprotect(String password) + public IXLSheetProtection Unprotect(string password) { return Protection.Unprotect(password); } @@ -729,7 +756,7 @@ IXLElementProtection IXLProtectable.Unprotect() return Unprotect(); } - IXLElementProtection IXLProtectable.Unprotect(String password) + IXLElementProtection IXLProtectable.Unprotect(string password) { return Unprotect(password); } @@ -739,37 +766,37 @@ IXLElementProtection IXLProtectable.Unprotect(String password) return GetRangeForSort().Sort(); } - public new IXLRange Sort(String columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, - Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange Sort(string columnsToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, + bool matchCase = false, bool ignoreBlanks = true) { return GetRangeForSort().Sort(columnsToSortBy, sortOrder, matchCase, ignoreBlanks); } - public new IXLRange Sort(Int32 columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, - Boolean matchCase = false, Boolean ignoreBlanks = true) + public new IXLRange Sort(int columnToSortBy, XLSortOrder sortOrder = XLSortOrder.Ascending, + bool matchCase = false, bool ignoreBlanks = true) { return GetRangeForSort().Sort(columnToSortBy, sortOrder, matchCase, ignoreBlanks); } - public new IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, Boolean matchCase = false, - Boolean ignoreBlanks = true) + public new IXLRange SortLeftToRight(XLSortOrder sortOrder = XLSortOrder.Ascending, bool matchCase = false, + bool ignoreBlanks = true) { return GetRangeForSort().SortLeftToRight(sortOrder, matchCase, ignoreBlanks); } - public Boolean ShowFormulas { get; set; } + public bool ShowFormulas { get; set; } - public Boolean ShowGridLines { get; set; } + public bool ShowGridLines { get; set; } - public Boolean ShowOutlineSymbols { get; set; } + public bool ShowOutlineSymbols { get; set; } - public Boolean ShowRowColHeaders { get; set; } + public bool ShowRowColHeaders { get; set; } - public Boolean ShowRuler { get; set; } + public bool ShowRuler { get; set; } - public Boolean ShowWhiteSpace { get; set; } + public bool ShowWhiteSpace { get; set; } - public Boolean ShowZeros { get; set; } + public bool ShowZeros { get; set; } public IXLWorksheet SetShowFormulas() { @@ -777,7 +804,7 @@ public IXLWorksheet SetShowFormulas() return this; } - public IXLWorksheet SetShowFormulas(Boolean value) + public IXLWorksheet SetShowFormulas(bool value) { ShowFormulas = value; return this; @@ -789,7 +816,7 @@ public IXLWorksheet SetShowGridLines() return this; } - public IXLWorksheet SetShowGridLines(Boolean value) + public IXLWorksheet SetShowGridLines(bool value) { ShowGridLines = value; return this; @@ -801,7 +828,7 @@ public IXLWorksheet SetShowOutlineSymbols() return this; } - public IXLWorksheet SetShowOutlineSymbols(Boolean value) + public IXLWorksheet SetShowOutlineSymbols(bool value) { ShowOutlineSymbols = value; return this; @@ -813,7 +840,7 @@ public IXLWorksheet SetShowRowColHeaders() return this; } - public IXLWorksheet SetShowRowColHeaders(Boolean value) + public IXLWorksheet SetShowRowColHeaders(bool value) { ShowRowColHeaders = value; return this; @@ -825,7 +852,7 @@ public IXLWorksheet SetShowRuler() return this; } - public IXLWorksheet SetShowRuler(Boolean value) + public IXLWorksheet SetShowRuler(bool value) { ShowRuler = value; return this; @@ -837,7 +864,7 @@ public IXLWorksheet SetShowWhiteSpace() return this; } - public IXLWorksheet SetShowWhiteSpace(Boolean value) + public IXLWorksheet SetShowWhiteSpace(bool value) { ShowWhiteSpace = value; return this; @@ -849,7 +876,7 @@ public IXLWorksheet SetShowZeros() return this; } - public IXLWorksheet SetShowZeros(Boolean value) + public IXLWorksheet SetShowZeros(bool value) { ShowZeros = value; return this; @@ -863,17 +890,19 @@ public IXLWorksheet SetTabColor(XLColor color) return this; } - public Boolean TabSelected { get; set; } + public bool TabSelected { get; set; } - public Boolean TabActive + public bool TabActive { get { return _tabActive; } set { if (value && !_tabActive) { - foreach (XLWorksheet ws in Worksheet.Workbook.WorksheetsInternal) + foreach (var ws in Worksheet.Workbook.WorksheetsInternal) + { ws._tabActive = false; + } } _tabActive = value; } @@ -885,7 +914,7 @@ public IXLWorksheet SetTabSelected() return this; } - public IXLWorksheet SetTabSelected(Boolean value) + public IXLWorksheet SetTabSelected(bool value) { TabSelected = value; return this; @@ -897,20 +926,20 @@ public IXLWorksheet SetTabActive() return this; } - public IXLWorksheet SetTabActive(Boolean value) + public IXLWorksheet SetTabActive(bool value) { TabActive = value; return this; } - IXLPivotTable IXLWorksheet.PivotTable(String name) + IXLPivotTable IXLWorksheet.PivotTable(string name) { return PivotTable(name); } public IXLPivotTables PivotTables { get; private set; } - public Boolean RightToLeft { get; set; } + public bool RightToLeft { get; set; } public IXLWorksheet SetRightToLeft() { @@ -918,16 +947,16 @@ public IXLWorksheet SetRightToLeft() return this; } - public IXLWorksheet SetRightToLeft(Boolean value) + public IXLWorksheet SetRightToLeft(bool value) { RightToLeft = value; return this; } - public override IXLRanges Ranges(String ranges) + public override IXLRanges Ranges(string ranges) { var retVal = new XLRanges(); - foreach (string rangeAddressStr in ranges.Split(',').Select(s => s.Trim())) + foreach (var rangeAddressStr in ranges.Split(',').Select(s => s.Trim())) { if (rangeAddressStr.StartsWith("#REF!")) { @@ -937,11 +966,11 @@ public override IXLRanges Ranges(String ranges) { retVal.Add(Range(new XLRangeAddress(Worksheet, rangeAddressStr))); } - else if (NamedRanges.TryGetValue(rangeAddressStr, out IXLNamedRange worksheetNamedRange)) + else if (NamedRanges.TryGetValue(rangeAddressStr, out var worksheetNamedRange)) { worksheetNamedRange.Ranges.ForEach(retVal.Add); } - else if (Workbook.NamedRanges.TryGetValue(rangeAddressStr, out IXLNamedRange workbookNamedRange) + else if (Workbook.NamedRanges.TryGetValue(rangeAddressStr, out var workbookNamedRange) && workbookNamedRange.Ranges.First().Worksheet == this) { workbookNamedRange.Ranges.ForEach(retVal.Add); @@ -950,13 +979,10 @@ public override IXLRanges Ranges(String ranges) return retVal; } - IXLAutoFilter IXLWorksheet.AutoFilter - { - get { return AutoFilter; } - } + IXLAutoFilter IXLWorksheet.AutoFilter => AutoFilter; [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLRows RowsUsed(Boolean includeFormats, Func predicate = null) + public IXLRows RowsUsed(bool includeFormats, Func predicate = null) { return RowsUsed(includeFormats ? XLCellsUsedOptions.All @@ -964,28 +990,30 @@ public IXLRows RowsUsed(Boolean includeFormats, Func predicate predicate); } - public IXLRows RowsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null) + public IXLRows RowsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null) { var rows = new XLRows(Worksheet, StyleValue); - var rowsUsed = new HashSet(); + var rowsUsed = new HashSet(); Internals.RowsCollection.Keys.ForEach(r => rowsUsed.Add(r)); Internals.CellsCollection.RowsUsed.Keys.ForEach(r => rowsUsed.Add(r)); foreach (var rowNum in rowsUsed) { var row = Row(rowNum); if (!row.IsEmpty(options) && (predicate == null || predicate(row))) + { rows.Add(row); + } } return rows; } - public IXLRows RowsUsed(Func predicate = null) + public IXLRows RowsUsed(Func predicate = null) { return RowsUsed(XLCellsUsedOptions.AllContents, predicate); } [Obsolete("Use the overload with XLCellsUsedOptions")] - public IXLColumns ColumnsUsed(Boolean includeFormats, Func predicate = null) + public IXLColumns ColumnsUsed(bool includeFormats, Func predicate = null) { return ColumnsUsed(includeFormats ? XLCellsUsedOptions.All @@ -993,22 +1021,24 @@ public IXLColumns ColumnsUsed(Boolean includeFormats, Func p predicate); } - public IXLColumns ColumnsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null) + public IXLColumns ColumnsUsed(XLCellsUsedOptions options = XLCellsUsedOptions.AllContents, Func predicate = null) { var columns = new XLColumns(Worksheet, StyleValue); - var columnsUsed = new HashSet(); + var columnsUsed = new HashSet(); Internals.ColumnsCollection.Keys.ForEach(r => columnsUsed.Add(r)); Internals.CellsCollection.ColumnsUsed.Keys.ForEach(r => columnsUsed.Add(r)); foreach (var columnNum in columnsUsed) { var column = Column(columnNum); if (!column.IsEmpty(options) && (predicate == null || predicate(column))) + { columns.Add(column); + } } return columns; } - public IXLColumns ColumnsUsed(Func predicate = null) + public IXLColumns ColumnsUsed(Func predicate = null) { return ColumnsUsed(XLCellsUsedOptions.AllContents, predicate); } @@ -1030,55 +1060,87 @@ internal void Cleanup() #region Outlines - public void IncrementColumnOutline(Int32 level) + public void IncrementColumnOutline(int level) { - if (level <= 0) return; - if (_columnOutlineCount.TryGetValue(level, out Int32 value)) + if (level <= 0) + { + return; + } + + if (_columnOutlineCount.TryGetValue(level, out var value)) + { _columnOutlineCount[level] = value + 1; + } else + { _columnOutlineCount.Add(level, 1); + } } - public void DecrementColumnOutline(Int32 level) + public void DecrementColumnOutline(int level) { - if (level <= 0) return; - if (_columnOutlineCount.TryGetValue(level, out Int32 value)) + if (level <= 0) + { + return; + } + + if (_columnOutlineCount.TryGetValue(level, out var value)) { if (value > 0) + { _columnOutlineCount[level] = value - 1; + } } else + { _columnOutlineCount.Add(level, 0); + } } - public Int32 GetMaxColumnOutline() + public int GetMaxColumnOutline() { var list = _columnOutlineCount.Where(kp => kp.Value > 0).ToList(); return list.Count == 0 ? 0 : list.Max(kp => kp.Key); } - public void IncrementRowOutline(Int32 level) + public void IncrementRowOutline(int level) { - if (level <= 0) return; - if (_rowOutlineCount.TryGetValue(level, out Int32 value)) + if (level <= 0) + { + return; + } + + if (_rowOutlineCount.TryGetValue(level, out var value)) + { _rowOutlineCount[level] = value + 1; + } else + { _rowOutlineCount.Add(level, 0); + } } - public void DecrementRowOutline(Int32 level) + public void DecrementRowOutline(int level) { - if (level <= 0) return; - if (_rowOutlineCount.TryGetValue(level, out Int32 value)) + if (level <= 0) + { + return; + } + + if (_rowOutlineCount.TryGetValue(level, out var value)) { if (value > 0) + { _rowOutlineCount[level] = level - 1; + } } else + { _rowOutlineCount.Add(level, 0); + } } - public Int32 GetMaxRowOutline() + public int GetMaxRowOutline() { return _rowOutlineCount.Count == 0 ? 0 : _rowOutlineCount.Where(kp => kp.Value > 0).Max(kp => kp.Key); } @@ -1149,18 +1211,22 @@ public XLColumn LastColumnUsed(XLCellsUsedOptions options) return rngColumn != null ? Column(rngColumn.RangeAddress.LastAddress.ColumnNumber) : null; } - public XLRow Row(Int32 row) + public XLRow Row(int row) { return Row(row, true); } - public XLColumn Column(Int32 columnNumber) + public XLColumn Column(int columnNumber) { if (columnNumber <= 0 || columnNumber > XLHelper.MaxColumnNumber) + { throw new ArgumentOutOfRangeException(nameof(columnNumber), $"Column number must be between 1 and {XLHelper.MaxColumnNumber}"); + } - if (Internals.ColumnsCollection.TryGetValue(columnNumber, out XLColumn column)) + if (Internals.ColumnsCollection.TryGetValue(columnNumber, out var column)) + { return column; + } else { // This is a new column so we're going to reference all @@ -1174,7 +1240,7 @@ public XLColumn Column(Int32 columnNumber) return column; } - public IXLColumn Column(String column) + public IXLColumn Column(string column) { return Column(XLHelper.GetColumnNumberFromLetter(column)); } @@ -1214,7 +1280,7 @@ private void ShiftPageBreaksColumns(XLRange range, int columnsShifted) { for (var i = 0; i < PageSetup.ColumnBreaks.Count; i++) { - int br = PageSetup.ColumnBreaks[i]; + var br = PageSetup.ColumnBreaks[i]; if (range.RangeAddress.FirstAddress.ColumnNumber <= br) { PageSetup.ColumnBreaks[i] = br + columnsShifted; @@ -1224,11 +1290,18 @@ private void ShiftPageBreaksColumns(XLRange range, int columnsShifted) private void ShiftConditionalFormattingColumns(XLRange range, int columnsShifted) { - if (!ConditionalFormats.Any()) return; - Int32 firstCol = range.RangeAddress.FirstAddress.ColumnNumber; - if (firstCol == 1) return; + if (!ConditionalFormats.Any()) + { + return; + } + + var firstCol = range.RangeAddress.FirstAddress.ColumnNumber; + if (firstCol == 1) + { + return; + } - int colNum = columnsShifted > 0 ? firstCol - 1 : firstCol; + var colNum = columnsShifted > 0 ? firstCol - 1 : firstCol; var model = Column(colNum).AsRange(); foreach (var cf in ConditionalFormats.ToList()) @@ -1255,26 +1328,39 @@ private void ShiftConditionalFormattingColumns(XLRange range, int columnsShifted Math.Min(XLHelper.MaxColumnNumber, cfAddress.LastAddress.ColumnNumber + columnsShifted)); } else + { newRange = cfRange; + } if (newRange.RangeAddress.IsValid && newRange.RangeAddress.FirstAddress.ColumnNumber <= newRange.RangeAddress.LastAddress.ColumnNumber) + { cf.Ranges.Add(newRange); + } } if (!cf.Ranges.Any()) + { ConditionalFormats.Remove(f => f == cf); + } } } private void ShiftDataValidationColumns(XLRange range, int columnsShifted) { - if (!DataValidations.Any()) return; - Int32 firstCol = range.RangeAddress.FirstAddress.ColumnNumber; - if (firstCol == 1) return; + if (!DataValidations.Any()) + { + return; + } + + var firstCol = range.RangeAddress.FirstAddress.ColumnNumber; + if (firstCol == 1) + { + return; + } - int colNum = columnsShifted > 0 ? firstCol - 1 : firstCol; + var colNum = columnsShifted > 0 ? firstCol - 1 : firstCol; var model = Column(colNum).AsRange(); foreach (var dv in DataValidations.ToList()) @@ -1301,16 +1387,22 @@ private void ShiftDataValidationColumns(XLRange range, int columnsShifted) Math.Min(XLHelper.MaxColumnNumber, dvAddress.LastAddress.ColumnNumber + columnsShifted)); } else + { newRange = dvRange; + } if (newRange.RangeAddress.IsValid && newRange.RangeAddress.FirstAddress.ColumnNumber <= newRange.RangeAddress.LastAddress.ColumnNumber) + { dv.AddRange(newRange); + } } if (!dv.Ranges.Any()) + { DataValidations.Delete(v => v == dv); + } } } @@ -1344,7 +1436,7 @@ private void ShiftPageBreaksRows(XLRange range, int rowsShifted) { for (var i = 0; i < PageSetup.RowBreaks.Count; i++) { - int br = PageSetup.RowBreaks[i]; + var br = PageSetup.RowBreaks[i]; if (range.RangeAddress.FirstAddress.RowNumber <= br) { PageSetup.RowBreaks[i] = br + rowsShifted; @@ -1354,11 +1446,18 @@ private void ShiftPageBreaksRows(XLRange range, int rowsShifted) private void ShiftConditionalFormattingRows(XLRange range, int rowsShifted) { - if (!ConditionalFormats.Any()) return; - Int32 firstRow = range.RangeAddress.FirstAddress.RowNumber; - if (firstRow == 1) return; + if (!ConditionalFormats.Any()) + { + return; + } + + var firstRow = range.RangeAddress.FirstAddress.RowNumber; + if (firstRow == 1) + { + return; + } - int rowNum = rowsShifted > 0 ? firstRow - 1 : firstRow; + var rowNum = rowsShifted > 0 ? firstRow - 1 : firstRow; var model = Row(rowNum).AsRange(); foreach (var cf in ConditionalFormats.ToList()) @@ -1385,25 +1484,38 @@ private void ShiftConditionalFormattingRows(XLRange range, int rowsShifted) cfAddress.LastAddress.ColumnNumber); } else + { newRange = cfRange; + } if (newRange.RangeAddress.IsValid && newRange.RangeAddress.FirstAddress.RowNumber <= newRange.RangeAddress.LastAddress.RowNumber) + { cf.Ranges.Add(newRange); + } } if (!cf.Ranges.Any()) + { ConditionalFormats.Remove(f => f == cf); + } } } private void ShiftDataValidationRows(XLRange range, int rowsShifted) { - if (!DataValidations.Any()) return; - Int32 firstRow = range.RangeAddress.FirstAddress.RowNumber; - if (firstRow == 1) return; + if (!DataValidations.Any()) + { + return; + } + + var firstRow = range.RangeAddress.FirstAddress.RowNumber; + if (firstRow == 1) + { + return; + } - int rowNum = rowsShifted > 0 ? firstRow - 1 : firstRow; + var rowNum = rowsShifted > 0 ? firstRow - 1 : firstRow; var model = Row(rowNum).AsRange(); foreach (var dv in DataValidations.ToList()) @@ -1430,15 +1542,21 @@ private void ShiftDataValidationRows(XLRange range, int rowsShifted) dvAddress.LastAddress.ColumnNumber); } else + { newRange = dvRange; + } if (newRange.RangeAddress.IsValid && newRange.RangeAddress.FirstAddress.RowNumber <= newRange.RangeAddress.LastAddress.RowNumber) + { dv.AddRange(newRange); + } } if (!dv.Ranges.Any()) + { DataValidations.Delete(v => v == dv); + } } } @@ -1476,7 +1594,7 @@ private void MoveNamedRangesColumns(XLRange range, int columnsShifted, IXLNamedR } } - public void NotifyRangeShiftedRows(XLRange range, Int32 rowsShifted) + public void NotifyRangeShiftedRows(XLRange range, int rowsShifted) { try { @@ -1492,10 +1610,14 @@ public void NotifyRangeShiftedRows(XLRange range, Int32 rowsShifted) foreach (var storedRange in rangesToShift) { if (storedRange.IsEntireColumn()) + { continue; + } if (ReferenceEquals(range, storedRange)) + { continue; + } storedRange.WorksheetRangeShiftedRows(range, rowsShifted); } @@ -1507,7 +1629,7 @@ public void NotifyRangeShiftedRows(XLRange range, Int32 rowsShifted) } } - public void NotifyRangeShiftedColumns(XLRange range, Int32 columnsShifted) + public void NotifyRangeShiftedColumns(XLRange range, int columnsShifted) { try { @@ -1523,10 +1645,14 @@ public void NotifyRangeShiftedColumns(XLRange range, Int32 columnsShifted) foreach (var storedRange in rangesToShift) { if (storedRange.IsEntireRow()) + { continue; + } if (ReferenceEquals(range, storedRange)) + { continue; + } storedRange.WorksheetRangeShiftedColumns(range, columnsShifted); } @@ -1538,13 +1664,17 @@ public void NotifyRangeShiftedColumns(XLRange range, Int32 columnsShifted) } } - public XLRow Row(Int32 rowNumber, Boolean pingCells) + public XLRow Row(int rowNumber, bool pingCells) { if (rowNumber <= 0 || rowNumber > XLHelper.MaxRowNumber) + { throw new ArgumentOutOfRangeException(nameof(rowNumber), $"Row number must be between 1 and {XLHelper.MaxRowNumber}"); + } - if (Internals.RowsCollection.TryGetValue(rowNumber, out XLRow row)) + if (Internals.RowsCollection.TryGetValue(rowNumber, out var row)) + { return row; + } else { if (pingCells) @@ -1562,12 +1692,12 @@ public XLRow Row(Int32 rowNumber, Boolean pingCells) return row; } - public IXLTable Table(XLRange range, Boolean addToTables, Boolean setAutofilter = true) + public IXLTable Table(XLRange range, bool addToTables, bool setAutofilter = true) { return Table(range, GetNewTableName("Table"), addToTables, setAutofilter); } - public IXLTable Table(XLRange range, String name, Boolean addToTables, Boolean setAutofilter = true) + public IXLTable Table(XLRange range, string name, bool addToTables, bool setAutofilter = true) { CheckRangeNotOverlappingOtherEntities(range); XLRangeAddress rangeAddress; @@ -1577,13 +1707,14 @@ public IXLTable Table(XLRange range, String name, Boolean addToTables, Boolean s range.InsertRowsBelow(1); } else + { rangeAddress = range.RangeAddress; + } var rangeKey = new XLRangeKey(XLRangeType.Table, rangeAddress); var table = (XLTable)_rangeRepository.GetOrCreate(ref rangeKey); - if (table.Name != name) - table.Name = name; + table.Name = name; if (addToTables && !Tables.Contains(table)) { @@ -1591,7 +1722,9 @@ public IXLTable Table(XLRange range, String name, Boolean addToTables, Boolean s } if (setAutofilter && !table.ShowAutoFilter) + { table.InitializeAutoFilter(); + } return table; } @@ -1601,17 +1734,21 @@ private void CheckRangeNotOverlappingOtherEntities(XLRange range) // Check that the range doesn't overlap with any existing tables var firstOverlappingTable = Tables.FirstOrDefault(t => t.RangeUsed().Intersects(range)); if (firstOverlappingTable != null) + { throw new InvalidOperationException($"The range {range.RangeAddress.ToStringRelative(includeSheet: true)} is already part of table '{firstOverlappingTable.Name}'"); + } // Check that the range doesn't overlap with any filters - if (AutoFilter.IsEnabled && this.AutoFilter.Range.Intersects(range)) + if (AutoFilter.IsEnabled && AutoFilter.Range.Intersects(range)) + { throw new InvalidOperationException($"The range {range.RangeAddress.ToStringRelative(includeSheet: true)} overlaps with the worksheet's autofilter."); + } } private string GetNewTableName(string baseName) { - var existingTableNames = new HashSet( - this.Workbook.Worksheets + var existingTableNames = new HashSet( + Workbook.Worksheets .SelectMany(ws => ws.Tables) .Select(t => t.Name), StringComparer.OrdinalIgnoreCase); @@ -1635,7 +1772,7 @@ private IXLRange GetRangeForSort() return range; } - public XLPivotTable PivotTable(String name) + public XLPivotTable PivotTable(string name) { return (XLPivotTable)PivotTables.PivotTable(name); } @@ -1645,25 +1782,34 @@ public override IXLCells Cells() return Cells(true, XLCellsUsedOptions.All); } - public override IXLCells Cells(Boolean usedCellsOnly) + public override IXLCells Cells(bool usedCellsOnly) { if (usedCellsOnly) + { return Cells(true, XLCellsUsedOptions.AllContents); + } else + { return Range((this as IXLRangeBase).FirstCellUsed(XLCellsUsedOptions.All), (this as IXLRangeBase).LastCellUsed(XLCellsUsedOptions.All)) .Cells(false, XLCellsUsedOptions.All); + } } - public override XLCell Cell(String cellAddressInRange) + public override XLCell Cell(string cellAddressInRange) { var cell = base.Cell(cellAddressInRange); - if (cell != null) return cell; + if (cell != null) + { + return cell; + } - if (Workbook.NamedRanges.TryGetValue(cellAddressInRange, out IXLNamedRange workbookNamedRange)) + if (Workbook.NamedRanges.TryGetValue(cellAddressInRange, out var workbookNamedRange)) { if (!workbookNamedRange.Ranges.Any()) + { return null; + } return workbookNamedRange.Ranges.FirstOrDefault().FirstCell().CastTo(); } @@ -1671,21 +1817,29 @@ public override XLCell Cell(String cellAddressInRange) return null; } - public override XLRange Range(String rangeAddressStr) + public override XLRange Range(string rangeAddressStr) { if (XLHelper.IsValidRangeAddress(rangeAddressStr)) + { return Range(new XLRangeAddress(Worksheet, rangeAddressStr)); + } if (rangeAddressStr.Contains("[")) + { return Table(rangeAddressStr.Substring(0, rangeAddressStr.IndexOf("["))) as XLRange; + } - if (NamedRanges.TryGetValue(rangeAddressStr, out IXLNamedRange worksheetNamedRange)) + if (NamedRanges.TryGetValue(rangeAddressStr, out var worksheetNamedRange)) + { return worksheetNamedRange.Ranges.First().CastTo(); + } - if (Workbook.NamedRanges.TryGetValue(rangeAddressStr, out IXLNamedRange workbookNamedRange)) + if (Workbook.NamedRanges.TryGetValue(rangeAddressStr, out var workbookNamedRange)) { if (!workbookNamedRange.Ranges.Any()) + { return null; + } return workbookNamedRange.Ranges.First().CastTo(); } @@ -1693,13 +1847,13 @@ public override XLRange Range(String rangeAddressStr) return null; } - public IXLRanges MergedRanges { get { return Internals.MergedRanges; } } + public IXLRanges MergedRanges => Internals.MergedRanges; public IXLConditionalFormats ConditionalFormats { get; private set; } public IXLSparklineGroups SparklineGroups { get; private set; } - private Boolean _eventTracking; + private bool _eventTracking; public void SuspendEvents() { @@ -1731,12 +1885,9 @@ internal set private XLCalcEngine _calcEngine; - internal XLCalcEngine CalcEngine - { - get { return _calcEngine ?? (_calcEngine = new XLCalcEngine(this)); } - } + internal XLCalcEngine CalcEngine => _calcEngine ??= new XLCalcEngine(this); - public Object Evaluate(String expression) + public object Evaluate(string expression) { return CalcEngine.Evaluate(expression); } @@ -1749,16 +1900,16 @@ public void RecalculateAllFormulas() CellsUsed().Cast().ForEach(cell => cell.Evaluate(true)); } - public String Author { get; set; } + public string Author { get; set; } public override string ToString() { - return this.Name; + return Name; } public IXLPictures Pictures { get; private set; } - public Boolean IsPasswordProtected => Protection.IsPasswordProtected; + public bool IsPasswordProtected => Protection.IsPasswordProtected; public bool IsProtected => Protection.IsProtected; @@ -1792,12 +1943,12 @@ public IXLPicture AddPicture(Stream stream, XLPictureFormat format, string name) return Pictures.Add(stream, format, name); } - public IXLPicture AddPicture(Bitmap bitmap) + public IXLPicture AddPicture(SKCodec bitmap) { return Pictures.Add(bitmap); } - public IXLPicture AddPicture(Bitmap bitmap, string name) + public IXLPicture AddPicture(SKCodec bitmap, string name) { return Pictures.Add(bitmap, name); } @@ -1812,12 +1963,12 @@ public IXLPicture AddPicture(string imageFile, string name) return Pictures.Add(imageFile, name); } - public override Boolean IsEntireRow() + public override bool IsEntireRow() { return true; } - public override Boolean IsEntireColumn() + public override bool IsEntireColumn() { return true; } @@ -1825,11 +1976,17 @@ public override Boolean IsEntireColumn() internal void SetValue(T value, int ro, int co) where T : class { if (value == null) - this.Cell(ro, co).SetValue(String.Empty, setTableHeader: true, checkMergedRanges: false); + { + Cell(ro, co).SetValue(string.Empty, setTableHeader: true, checkMergedRanges: false); + } else if (value is IConvertible) - this.Cell(ro, co).SetValue((T)Convert.ChangeType(value, typeof(T)), setTableHeader: true, checkMergedRanges: false); + { + Cell(ro, co).SetValue((T)Convert.ChangeType(value, typeof(T)), setTableHeader: true, checkMergedRanges: false); + } else - this.Cell(ro, co).SetValue(value, setTableHeader: true, checkMergedRanges: false); + { + Cell(ro, co).SetValue(value, setTableHeader: true, checkMergedRanges: false); + } } /// @@ -1843,11 +2000,15 @@ internal object GetCellValue(int ro, int co) if (Internals.CellsCollection.MaxRowUsed < ro || Internals.CellsCollection.MaxColumnUsed < co || !Internals.CellsCollection.Contains(ro, co)) + { return string.Empty; + } var cell = Worksheet.Internals.CellsCollection.GetCell(ro, co); if (cell.IsEvaluating) + { return string.Empty; + } return cell.Value; } @@ -1857,7 +2018,9 @@ public XLRange GetOrCreateRange(XLRangeParameters xlRangeParameters) var rangeKey = new XLRangeKey(XLRangeType.Range, xlRangeParameters.RangeAddress); var range = _rangeRepository.GetOrCreate(ref rangeKey); if (xlRangeParameters.DefaultStyle != null && range.StyleValue == StyleValue) + { range.InnerStyle = xlRangeParameters.DefaultStyle; + } return range as XLRange; } @@ -1874,7 +2037,9 @@ public XLRangeRow RangeRow(XLRangeAddress address, IXLStyle defaultStyle = null) var rangeRow = (XLRangeRow)_rangeRepository.GetOrCreate(ref rangeKey); if (defaultStyle != null && rangeRow.StyleValue == StyleValue) + { rangeRow.InnerStyle = defaultStyle; + } return rangeRow; } @@ -1891,7 +2056,9 @@ public XLRangeColumn RangeColumn(XLRangeAddress address, IXLStyle defaultStyle = var rangeColumn = (XLRangeColumn)_rangeRepository.GetOrCreate(ref rangeKey); if (defaultStyle != null && rangeColumn.StyleValue == StyleValue) + { rangeColumn.InnerStyle = defaultStyle; + } return rangeColumn; } @@ -1903,7 +2070,9 @@ protected override void OnRangeAddressChanged(XLRangeAddress oldAddress, XLRange public void RellocateRange(XLRangeType rangeType, XLRangeAddress oldAddress, XLRangeAddress newAddress) { if (_rangeRepository == null) + { return; + } var oldKey = new XLRangeKey(rangeType, oldAddress); var newKey = new XLRangeKey(rangeType, newAddress); @@ -1912,7 +2081,9 @@ public void RellocateRange(XLRangeType rangeType, XLRangeAddress oldAddress, XLR foreach (var rangeIndex in _rangeIndices) { if (!rangeIndex.MatchesType(rangeType)) + { continue; + } if (rangeIndex.Remove(oldAddress) && newAddress.IsValid && @@ -1927,8 +2098,8 @@ internal void DeleteColumn(int columnNumber) { Internals.ColumnsCollection.Remove(columnNumber); - var columnsToMove = new List(Internals.ColumnsCollection.Where(c => c.Key > columnNumber).Select(c => c.Key).OrderBy(c => c)); - foreach (int column in columnsToMove) + var columnsToMove = new List(Internals.ColumnsCollection.Where(c => c.Key > columnNumber).Select(c => c.Key).OrderBy(c => c)); + foreach (var column in columnsToMove) { Internals.ColumnsCollection.Add(column - 1, Internals.ColumnsCollection[column]); Internals.ColumnsCollection.Remove(column); @@ -1941,8 +2112,8 @@ internal void DeleteRow(int rowNumber) { Internals.RowsCollection.Remove(rowNumber); - var rowsToMove = new List(Internals.RowsCollection.Where(c => c.Key > rowNumber).Select(c => c.Key).OrderBy(r => r)); - foreach (int row in rowsToMove) + var rowsToMove = new List(Internals.RowsCollection.Where(c => c.Key > rowNumber).Select(c => c.Key).OrderBy(r => r)); + foreach (var row in rowsToMove) { Internals.RowsCollection.Add(row - 1, Worksheet.Internals.RowsCollection[row]); Internals.RowsCollection.Remove(row); @@ -1957,4 +2128,4 @@ internal void DeleteRange(XLRangeAddress rangeAddress) _rangeRepository.Remove(ref rangeKey); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Excel/XLWorksheetInternals.cs b/ClosedXML/Excel/XLWorksheetInternals.cs index ea5a915fb..833e2b07c 100644 --- a/ClosedXML/Excel/XLWorksheetInternals.cs +++ b/ClosedXML/Excel/XLWorksheetInternals.cs @@ -4,12 +4,13 @@ namespace ClosedXML.Excel { internal class XLWorksheetInternals : IDisposable { + private bool _disposed; + public XLWorksheetInternals( XLCellsCollection cellsCollection, XLColumnsCollection columnsCollection, XLRowsCollection rowsCollection, - XLRanges mergedRanges - ) + XLRanges mergedRanges) { CellsCollection = cellsCollection; ColumnsCollection = columnsCollection; @@ -22,30 +23,30 @@ XLRanges mergedRanges public XLRowsCollection RowsCollection { get; private set; } public XLRanges MergedRanges { get; internal set; } - // Used by Janitor.Fody - private void DisposeManaged() - { - CellsCollection.Clear(); - ColumnsCollection.Clear(); - RowsCollection.Clear(); - MergedRanges.RemoveAll(); - } - -#if _NET40_ - public void Dispose() { - // net40 doesn't support Janitor.Fody, so let's dispose manually - DisposeManaged(); + // Dispose of unmanaged resources. + Dispose(true); + // Suppress finalization. + GC.SuppressFinalize(this); } -#else - - public void Dispose() + public void Dispose(bool disposing) { - // Leave this empty (for non net40 targets) so that Janitor.Fody can do its work + if (_disposed) + { + return; + } + + if (disposing) + { + CellsCollection?.Clear(); + ColumnsCollection?.Clear(); + RowsCollection?.Clear(); + MergedRanges?.RemoveAll(); + } + + _disposed = true; } - -#endif } } diff --git a/ClosedXML/Excel/XLWorksheets.cs b/ClosedXML/Excel/XLWorksheets.cs index 25cd79d4a..a0e658ced 100644 --- a/ClosedXML/Excel/XLWorksheets.cs +++ b/ClosedXML/Excel/XLWorksheets.cs @@ -10,15 +10,15 @@ namespace ClosedXML.Excel internal class XLWorksheets : IXLWorksheets, IEnumerable { private readonly XLWorkbook _workbook; - private readonly Dictionary _worksheets = new Dictionary(StringComparer.OrdinalIgnoreCase); - internal ICollection Deleted { get; private set; } + private readonly Dictionary _worksheets = new Dictionary(StringComparer.OrdinalIgnoreCase); + internal ICollection Deleted { get; private set; } #region Constructor public XLWorksheets(XLWorkbook workbook) { _workbook = workbook; - Deleted = new HashSet(); + Deleted = new HashSet(); } #endregion Constructor @@ -40,14 +40,14 @@ public int Count get { return _worksheets.Count; } } - public Boolean Contains(String sheetName) + public bool Contains(string sheetName) { return _worksheets.ContainsKey(sheetName); } public bool TryGetWorksheet(string sheetName, out IXLWorksheet worksheet) { - if (_worksheets.TryGetValue(sheetName.UnescapeSheetName(), out XLWorksheet w)) + if (_worksheets.TryGetValue(sheetName.UnescapeSheetName(), out var w)) { worksheet = w; return true; @@ -56,21 +56,25 @@ public bool TryGetWorksheet(string sheetName, out IXLWorksheet worksheet) return false; } - public IXLWorksheet Worksheet(String sheetName) + public IXLWorksheet Worksheet(string sheetName) { sheetName = sheetName.UnescapeSheetName(); - if (_worksheets.TryGetValue(sheetName, out XLWorksheet w)) + if (_worksheets.TryGetValue(sheetName, out var w)) + { return w; + } throw new ArgumentException("There isn't a worksheet named '" + sheetName + "'."); } - public IXLWorksheet Worksheet(Int32 position) + public IXLWorksheet Worksheet(int position) { - int wsCount = _worksheets.Values.Count(w => w.Position == position); + var wsCount = _worksheets.Values.Count(w => w.Position == position); if (wsCount == 0) + { throw new ArgumentException("There isn't a worksheet associated with that position."); + } if (wsCount > 1) { @@ -86,12 +90,12 @@ public IXLWorksheet Add() return Add(GetNextWorksheetName()); } - public IXLWorksheet Add(Int32 position) + public IXLWorksheet Add(int position) { return Add(GetNextWorksheetName(), position); } - public IXLWorksheet Add(String sheetName) + public IXLWorksheet Add(string sheetName) { var sheet = new XLWorksheet(sheetName, _workbook); Add(sheetName, sheet); @@ -99,7 +103,7 @@ public IXLWorksheet Add(String sheetName) return sheet; } - public IXLWorksheet Add(String sheetName, Int32 position) + public IXLWorksheet Add(string sheetName, int position) { _worksheets.Values.Where(w => w._position >= position).ForEach(w => w._position += 1); _workbook.UnsupportedSheets.Where(w => w.Position >= position).ForEach(w => w.Position += 1); @@ -109,32 +113,40 @@ public IXLWorksheet Add(String sheetName, Int32 position) return sheet; } - private void Add(String sheetName, XLWorksheet sheet) + private void Add(string sheetName, XLWorksheet sheet) { if (_worksheets.ContainsKey(sheetName)) - throw new ArgumentException(String.Format("A worksheet with the same name ({0}) has already been added.", sheetName), nameof(sheetName)); + { + throw new ArgumentException(string.Format("A worksheet with the same name ({0}) has already been added.", sheetName), nameof(sheetName)); + } _worksheets.Add(sheetName, sheet); } - public void Delete(String sheetName) + public void Delete(string sheetName) { Delete(_worksheets[sheetName].Position); } - public void Delete(Int32 position) + public void Delete(int position) { - int wsCount = _worksheets.Values.Count(w => w.Position == position); + var wsCount = _worksheets.Values.Count(w => w.Position == position); if (wsCount == 0) + { throw new ArgumentException("There isn't a worksheet associated with that index."); + } if (wsCount > 1) + { throw new ArgumentException( "Can't delete the worksheet because there are multiple worksheets associated with that index."); + } var ws = _worksheets.Values.Single(w => w.Position == position); - if (!String.IsNullOrWhiteSpace(ws.RelId) && !Deleted.Contains(ws.RelId)) + if (!string.IsNullOrWhiteSpace(ws.RelId) && !Deleted.Contains(ws.RelId)) + { Deleted.Add(ws.RelId); + } _worksheets.RemoveAll(w => w.Position == position); _worksheets.Values.Where(w => w.Position > position).ForEach(w => w._position -= 1); @@ -159,7 +171,7 @@ public IXLWorksheet Add(DataTable dataTable) return Add(dataTable, dataTable.TableName); } - public IXLWorksheet Add(DataTable dataTable, String sheetName) + public IXLWorksheet Add(DataTable dataTable, string sheetName) { var ws = Add(sheetName); ws.Cell(1, 1).InsertTable(dataTable, sheetName); @@ -169,18 +181,25 @@ public IXLWorksheet Add(DataTable dataTable, String sheetName) public void Add(DataSet dataSet) { foreach (DataTable t in dataSet.Tables) + { Add(t); + } } #endregion IXLWorksheets Members - public void Rename(String oldSheetName, String newSheetName) + public void Rename(string oldSheetName, string newSheetName) { - if (String.IsNullOrWhiteSpace(oldSheetName) || !_worksheets.TryGetValue(oldSheetName, out XLWorksheet ws)) return; + if (string.IsNullOrWhiteSpace(oldSheetName) || !_worksheets.TryGetValue(oldSheetName, out var ws)) + { + return; + } if (!oldSheetName.Equals(newSheetName, StringComparison.OrdinalIgnoreCase) && _worksheets.ContainsKey(newSheetName)) - throw new ArgumentException(String.Format("A worksheet with the same name ({0}) has already been added.", newSheetName), nameof(newSheetName)); + { + throw new ArgumentException(string.Format("A worksheet with the same name ({0}) has already been added.", newSheetName), nameof(newSheetName)); + } _worksheets.Remove(oldSheetName); Add(newSheetName, ws); @@ -188,9 +207,9 @@ public void Rename(String oldSheetName, String newSheetName) #region Private members - private String GetNextWorksheetName() + private string GetNextWorksheetName() { - var worksheetNumber = this.Count + 1; + var worksheetNumber = Count + 1; var sheetName = $"Sheet{worksheetNumber}"; while (_worksheets.Values.Any(p => p.Name.Equals(sheetName, StringComparison.OrdinalIgnoreCase))) { diff --git a/ClosedXML/Extensions/ColorExtensions.cs b/ClosedXML/Extensions/ColorExtensions.cs index b832509b6..f0b5a66a6 100644 --- a/ClosedXML/Extensions/ColorExtensions.cs +++ b/ClosedXML/Extensions/ColorExtensions.cs @@ -1,6 +1,6 @@ // Keep this file CodeMaid organised and cleaned -using System; -using System.Drawing; +using DocumentFormat.OpenXml.Spreadsheet; +using SkiaSharp; namespace ClosedXML.Excel { @@ -8,21 +8,21 @@ internal static class ColorExtensions { private static readonly char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; - public static String ToHex(this Color color) + public static string ToHex(this SKColor color) { - byte[] bytes = new byte[4]; + var bytes = new byte[4]; - bytes[0] = color.A; + bytes[0] = color.Alpha; - bytes[1] = color.R; + bytes[1] = color.Red; - bytes[2] = color.G; + bytes[2] = color.Green; - bytes[3] = color.B; + bytes[3] = color.Blue; - char[] chars = new char[bytes.Length * 2]; + var chars = new char[bytes.Length * 2]; - for (int i = 0; i < bytes.Length; i++) + for (var i = 0; i < bytes.Length; i++) { int b = bytes[i]; @@ -33,5 +33,14 @@ public static String ToHex(this Color color) return new string(chars); } + + internal static Color ConvertToOpenXmlColor(this SKColor sKColor) + { + var color = new Color + { + Rgb = new DocumentFormat.OpenXml.HexBinaryValue(sKColor.ToHex()) + }; + return color; + } } } diff --git a/ClosedXML/Extensions/DateTimeExtensions.cs b/ClosedXML/Extensions/DateTimeExtensions.cs index af989eb22..a5b1afb70 100644 --- a/ClosedXML/Extensions/DateTimeExtensions.cs +++ b/ClosedXML/Extensions/DateTimeExtensions.cs @@ -7,13 +7,7 @@ namespace ClosedXML.Excel { internal static class DateTimeExtensions { - public static Double MaxOADate - { - get - { - return 2958465.99999999; - } - } + public static double MaxOADate => 2958465.99999999; public static bool IsWorkDay(this DateTime date, IEnumerable bankHolidays) { @@ -26,7 +20,9 @@ public static DateTime NextWorkday(this DateTime date, IEnumerable ban { var nextDate = date.AddDays(1); while (!nextDate.IsWorkDay(bankHolidays)) + { nextDate = nextDate.AddDays(1); + } return nextDate; } @@ -35,7 +31,9 @@ public static DateTime PreviousWorkDay(this DateTime date, IEnumerable { var previousDate = date.AddDays(-1); while (!previousDate.IsWorkDay(bankHolidays)) + { previousDate = previousDate.AddDays(-1); + } return previousDate; } diff --git a/ClosedXML/Extensions/DoubleExtensions.cs b/ClosedXML/Extensions/DoubleExtensions.cs index 8a096f386..79c655ac8 100644 --- a/ClosedXML/Extensions/DoubleExtensions.cs +++ b/ClosedXML/Extensions/DoubleExtensions.cs @@ -5,7 +5,7 @@ namespace ClosedXML.Excel { internal static class DoubleExtensions { - public static Double SaveRound(this Double value) + public static double SaveRound(this double value) { return Math.Round(value, 6); } diff --git a/ClosedXML/Extensions/EnumerableExtensions.cs b/ClosedXML/Extensions/EnumerableExtensions.cs index 68049e48f..ceda7715e 100644 --- a/ClosedXML/Extensions/EnumerableExtensions.cs +++ b/ClosedXML/Extensions/EnumerableExtensions.cs @@ -10,8 +10,10 @@ internal static class EnumerableExtensions { public static void ForEach(this IEnumerable source, Action action) { - foreach (T item in source) + foreach (var item in source) + { action(item); + } } public static Type GetItemType(this IEnumerable source) @@ -21,7 +23,9 @@ public static Type GetItemType(this IEnumerable source) Type GetGenericArgument(Type collectionType) { if (collectionType == null) + { return null; + } var ienumerable = collectionType.GetInterfaces() .SingleOrDefault(i => i.GetGenericArguments().Length == 1 && @@ -31,9 +35,9 @@ Type GetGenericArgument(Type collectionType) } } - public static Boolean HasDuplicates(this IEnumerable source) + public static bool HasDuplicates(this IEnumerable source) { - HashSet distinctItems = new HashSet(); + var distinctItems = new HashSet(); foreach (var item in source) { if (!distinctItems.Add(item)) diff --git a/ClosedXML/Extensions/FontBaseExtensions.cs b/ClosedXML/Extensions/FontBaseExtensions.cs index 595865f1b..7cee736b4 100644 --- a/ClosedXML/Extensions/FontBaseExtensions.cs +++ b/ClosedXML/Extensions/FontBaseExtensions.cs @@ -1,13 +1,21 @@ -// Keep this file CodeMaid organised and cleaned +using ClosedXML.Excel; using ClosedXML.Utils; -using System; +using SkiaSharp; using System.Collections.Generic; -using System.Drawing; +using System.IO; -namespace ClosedXML.Excel +namespace ClosedXML.Extensions { internal static class FontBaseExtensions { + private const int maxExcelColumnHeight = 409; + private const int maxExcelColumnWidth = 255; + private const double knownExcelCellHeightForFontAvaliableOnMostOs150Pt = 188; + private const double knownExcelCellWidthForVeryWideTextWithFontAvaliableOnMostOs20Pt = 36.8d; + private const string EmbeddedFont = "DejaVu Serif"; + private static double? CachedWidthCalibrationFactor; + private static double? CachedHeightCalibrationFactor; + public static void CopyFont(this IXLFontBase font, IXLFontBase sourceFont) { font.Bold = sourceFont.Bold; @@ -23,45 +31,107 @@ public static void CopyFont(this IXLFontBase font, IXLFontBase sourceFont) font.FontCharSet = sourceFont.FontCharSet; } - public static Double GetHeight(this IXLFontBase fontBase, Dictionary fontCache) + public static double GetHeight(this IXLFontBase fontBase, Dictionary fontCache) + { + var systemSpecificWidthScalingFactor = GetCachedHeightCalibration(fontCache); + var height = SystemSpecificHeightCalculator(fontBase, fontCache, systemSpecificWidthScalingFactor); + var heightLimitedToMaxExcelValue = height < maxExcelColumnHeight ? height : maxExcelColumnHeight; + return heightLimitedToMaxExcelValue; + } + + private static double GetCachedHeightCalibration(Dictionary fontCache) + { + if (CachedHeightCalibrationFactor.HasValue) + { + return CachedHeightCalibrationFactor.Value; + } + + var xLFont = new XLFont + { + FontSize = 150, + FontName = EmbeddedFont + }; + + var SystemSpecificWidthOfKnownWidth = SystemSpecificHeightCalculator(xLFont, fontCache, 1); + CachedHeightCalibrationFactor = knownExcelCellHeightForFontAvaliableOnMostOs150Pt / SystemSpecificWidthOfKnownWidth; + return CachedHeightCalibrationFactor.Value; + } + + private static double SystemSpecificHeightCalculator(IXLFontBase fontBase, Dictionary fontCache, double systemSpecificHeightScalingFactor) { var font = GetCachedFont(fontBase, fontCache); + // textHeight vary between systems, + // A linear factor that is calculated by a known combination text size and known height looked up in ms excel in GetCachedHeightCalibration var textHeight = GraphicsUtils.MeasureString("X", font).Height; - return (double)textHeight * 0.85; + var height = textHeight * systemSpecificHeightScalingFactor; + return height; } - public static Double GetWidth(this IXLFontBase fontBase, String text, Dictionary fontCache) + public static double GetWidth(this IXLFontBase fontBase, string text, Dictionary fontCache) { - if (String.IsNullOrWhiteSpace(text)) + if (string.IsNullOrWhiteSpace(text)) + { return 0; + } + var systemSpecificWidthScalingFactor = GetCachedWidthCalibration(fontCache); + var width = SystemSpecificWidthCalculator(fontBase, text, fontCache, systemSpecificWidthScalingFactor); + var widhtLimitedToMaxWidhPossibleInExcel = width < maxExcelColumnWidth ? width : maxExcelColumnWidth; + return widhtLimitedToMaxWidhPossibleInExcel; + } - var font = GetCachedFont(fontBase, fontCache); - var textWidth = GraphicsUtils.MeasureString(text, font).Width; + private static double GetCachedWidthCalibration(Dictionary fontCache) + { + if (CachedWidthCalibrationFactor.HasValue) + { + return CachedWidthCalibrationFactor.Value; + } + + var text = "Very Wide Column"; - double width = (textWidth / 7d * 256 - 128 / 7) / 256; - width = Math.Round(width + 0.2, 2); + var xLFont = new XLFont + { + FontSize = 20, + FontName = EmbeddedFont + }; + + var systemSpecificWidthOfKnownWidth = SystemSpecificWidthCalculator(xLFont, text, fontCache, 1); + CachedWidthCalibrationFactor = knownExcelCellWidthForVeryWideTextWithFontAvaliableOnMostOs20Pt / systemSpecificWidthOfKnownWidth; - return width; + return CachedWidthCalibrationFactor.Value; } - private static Font GetCachedFont(IXLFontBase fontBase, Dictionary fontCache) + private static double SystemSpecificWidthCalculator(IXLFontBase fontBase, string text, Dictionary fontCache, double systemSpecificScalingFactor) { - if (!fontCache.TryGetValue(fontBase, out Font font)) + var font = GetCachedFont(fontBase, fontCache); + var marginPoints = ((font.Size * 0.4) + 8) / 1.326; + var textWidthPoints = GraphicsUtils.MeasureString(text, font).Width; + + // textWidthPoints vary between systems, + // A linear factor that is calculated by a known combination of text, text size and known width looked up in ms excel in GetCachedWidthCalibration + var columnWidth = (textWidthPoints + marginPoints) * systemSpecificScalingFactor; + return columnWidth; + } + + private static SKFont GetCachedFont(IXLFontBase fontBase, Dictionary fontCache) + { + if (!fontCache.TryGetValue(fontBase, out var font)) { - font = new Font(fontBase.FontName, (float)fontBase.FontSize, GetFontStyle(fontBase)); + using var fontManager = SKFontManager.CreateDefault(); + + SKTypeface typeface = null; + if (fontBase.FontName == EmbeddedFont) + { + using var embeddedFont = new MemoryStream(Properties.Resources.DejaVuSerif); + typeface = fontManager.CreateTypeface(embeddedFont); + } + else + { + typeface = fontManager.MatchFamily(fontBase.FontName); + } + font = new SKFont(typeface, (float)fontBase.FontSize); fontCache.Add(fontBase, font); } return font; } - - private static FontStyle GetFontStyle(IXLFontBase font) - { - FontStyle fontStyle = FontStyle.Regular; - if (font.Bold) fontStyle |= FontStyle.Bold; - if (font.Italic) fontStyle |= FontStyle.Italic; - if (font.Strikethrough) fontStyle |= FontStyle.Strikeout; - if (font.Underline != XLFontUnderlineValues.None) fontStyle |= FontStyle.Underline; - return fontStyle; - } } -} +} \ No newline at end of file diff --git a/ClosedXML/Extensions/FormatExtensions.cs b/ClosedXML/Extensions/FormatExtensions.cs index c8a3addd6..6a900cb4c 100644 --- a/ClosedXML/Extensions/FormatExtensions.cs +++ b/ClosedXML/Extensions/FormatExtensions.cs @@ -10,7 +10,9 @@ public static string ToExcelFormat(this object o, string format) { var nf = new NumberFormat(format); if (!nf.IsValid) + { return format; + } return nf.Format(o, CultureInfo.InvariantCulture); } diff --git a/ClosedXML/Extensions/GuidExtensions.cs b/ClosedXML/Extensions/GuidExtensions.cs index fe2f3a514..ab0f94f1b 100644 --- a/ClosedXML/Extensions/GuidExtensions.cs +++ b/ClosedXML/Extensions/GuidExtensions.cs @@ -5,7 +5,7 @@ namespace ClosedXML.Extensions { internal static class GuidExtensions { - internal static String WrapInBraces(this Guid guid) + internal static string WrapInBraces(this Guid guid) { return string.Concat('{', guid.ToString(), '}'); } diff --git a/ClosedXML/Extensions/ObjectExtensions.cs b/ClosedXML/Extensions/ObjectExtensions.cs index c4016baa7..abe260362 100644 --- a/ClosedXML/Extensions/ObjectExtensions.cs +++ b/ClosedXML/Extensions/ObjectExtensions.cs @@ -6,7 +6,7 @@ namespace ClosedXML.Excel { internal static class ObjectExtensions { - public static T CastTo(this Object o) + public static T CastTo(this object o) { return (T)Convert.ChangeType(o, typeof(T)); } diff --git a/ClosedXML/Extensions/OpenXmlPartContainerExtensions.cs b/ClosedXML/Extensions/OpenXmlPartContainerExtensions.cs index 3c5ed9351..4fc7f6687 100644 --- a/ClosedXML/Extensions/OpenXmlPartContainerExtensions.cs +++ b/ClosedXML/Extensions/OpenXmlPartContainerExtensions.cs @@ -1,13 +1,12 @@ // Keep this file CodeMaid organised and cleaned using DocumentFormat.OpenXml.Packaging; -using System; using System.Linq; namespace ClosedXML.Extensions { internal static class OpenXmlPartContainerExtensions { - public static Boolean HasPartWithId(this OpenXmlPartContainer container, String relId) + public static bool HasPartWithId(this OpenXmlPartContainer container, string relId) { return container.Parts.Any(p => p.RelationshipId.Equals(relId)); } diff --git a/ClosedXML/Extensions/StringExtensions.cs b/ClosedXML/Extensions/StringExtensions.cs index 527db3238..b78ea1f05 100644 --- a/ClosedXML/Extensions/StringExtensions.cs +++ b/ClosedXML/Extensions/StringExtensions.cs @@ -1,5 +1,4 @@ // Keep this file CodeMaid organised and cleaned -using System; using System.Linq; using System.Text; using System.Text.RegularExpressions; @@ -10,17 +9,17 @@ internal static class StringExtensions { private static readonly Regex RegexNewLine = new Regex(@"((? (Char.IsPunctuation(c) && c != '.' && c != '_') || - Char.IsSeparator(c) || - Char.IsControl(c) || - Char.IsSymbol(c)); + sheetName.Any(c => (char.IsPunctuation(c) && c != '.' && c != '_') || + char.IsSeparator(c) || + char.IsControl(c) || + char.IsSymbol(c)); if (needEscape) - return String.Concat('\'', sheetName.Replace("'", "''"), '\''); + { + return string.Concat('\'', sheetName.Replace("'", "''"), '\''); + } else + { return sheetName; + } } - internal static String FixNewLines(this String value) + internal static string FixNewLines(this string value) { - return value.Contains("\n") ? RegexNewLine.Replace(value, Environment.NewLine) : value; + return value.Contains("\n") ? RegexNewLine.Replace(value, XLConstants.NewLine) : value; } - internal static Boolean PreserveSpaces(this String value) + internal static bool PreserveSpaces(this string value) { - return value.StartsWith(" ") || value.EndsWith(" ") || value.Contains(Environment.NewLine); + return value.StartsWith(" ") || value.EndsWith(" ") || value.Contains(XLConstants.NewLine); } - internal static String ToCamel(this String value) + internal static string ToCamel(this string value) { if (value.Length == 0) + { return value; + } if (value.Length == 1) + { return value.ToLower(); + } return value.Substring(0, 1).ToLower() + value.Substring(1); } - internal static String ToProper(this String value) + internal static string ToProper(this string value) { if (value.Length == 0) + { return value; + } if (value.Length == 1) + { return value.ToUpper(); + } return value.Substring(0, 1).ToUpper() + value.Substring(1); } - internal static string UnescapeSheetName(this String sheetName) + internal static string UnescapeSheetName(this string sheetName) { return sheetName .Trim('\'') .Replace("''", "'"); } } -} +} \ No newline at end of file diff --git a/ClosedXML/Extensions/TypeExtensions.cs b/ClosedXML/Extensions/TypeExtensions.cs index 3b4433c4c..cb15cdc10 100644 --- a/ClosedXML/Extensions/TypeExtensions.cs +++ b/ClosedXML/Extensions/TypeExtensions.cs @@ -33,7 +33,7 @@ public static bool IsNumber(this Type type) public static bool IsSimpleType(this Type type) { return type.IsPrimitive - || type == typeof(String) + || type == typeof(string) || type == typeof(DateTime) || type == typeof(TimeSpan) || type.IsNumber(); diff --git a/ClosedXML/Extensions/XDocumentExtensions.cs b/ClosedXML/Extensions/XDocumentExtensions.cs index 36a7a4410..61df90b84 100644 --- a/ClosedXML/Extensions/XDocumentExtensions.cs +++ b/ClosedXML/Extensions/XDocumentExtensions.cs @@ -9,16 +9,14 @@ internal static class XDocumentExtensions { public static XDocument Load(Stream stream) { - using (XmlReader reader = XmlReader.Create(stream)) + using var reader = XmlReader.Create(stream); + try { - try - { - return XDocument.Load(reader); - } - catch (XmlException) - { - return null; - } + return XDocument.Load(reader); + } + catch (XmlException) + { + return null; } } } diff --git a/ClosedXML/FodyWeavers.xml b/ClosedXML/FodyWeavers.xml deleted file mode 100644 index 958bbfca4..000000000 --- a/ClosedXML/FodyWeavers.xml +++ /dev/null @@ -1,3 +0,0 @@ - - - \ No newline at end of file diff --git a/ClosedXML/FodyWeavers.xsd b/ClosedXML/FodyWeavers.xsd deleted file mode 100644 index df82d5f85..000000000 --- a/ClosedXML/FodyWeavers.xsd +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed. - - - - - A comma-separated list of error codes that can be safely ignored in assembly verification. - - - - - 'false' to turn off automatic generation of the XML Schema file. - - - - - \ No newline at end of file diff --git a/ClosedXML/Product.png b/ClosedXML/Product.png new file mode 100644 index 000000000..45a4c406a Binary files /dev/null and b/ClosedXML/Product.png differ diff --git a/ClosedXML/Properties/Resources.Designer.cs b/ClosedXML/Properties/Resources.Designer.cs new file mode 100644 index 000000000..49dd3fc5a --- /dev/null +++ b/ClosedXML/Properties/Resources.Designer.cs @@ -0,0 +1,73 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ClosedXML.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ClosedXML.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] DejaVuSerif { + get { + object obj = ResourceManager.GetObject("DejaVuSerif", resourceCulture); + return ((byte[])(obj)); + } + } + } +} diff --git a/ClosedXML/Properties/Resources.resx b/ClosedXML/Properties/Resources.resx new file mode 100644 index 000000000..6bb5d8dbb --- /dev/null +++ b/ClosedXML/Properties/Resources.resx @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Resources\DejaVuSerif.ttf;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ClosedXML/Resources/DejaVuSerif.ttf b/ClosedXML/Resources/DejaVuSerif.ttf new file mode 100644 index 000000000..0b803d206 Binary files /dev/null and b/ClosedXML/Resources/DejaVuSerif.ttf differ diff --git a/ClosedXML/Utils/ColorStringParser.cs b/ClosedXML/Utils/ColorStringParser.cs index b56552b36..85486f72a 100644 --- a/ClosedXML/Utils/ColorStringParser.cs +++ b/ClosedXML/Utils/ColorStringParser.cs @@ -1,25 +1,39 @@ -using System.Drawing; +using SkiaSharp; +using System; using System.Globalization; +using System.Linq; +using System.Reflection; namespace ClosedXML.Utils { internal static class ColorStringParser { - public static Color ParseFromHtml(string htmlColor) + public static SKColor ParseFromHtml(string htmlColor) { - try - { - if (htmlColor[0] != '#') - htmlColor = '#' + htmlColor; + return FromArgb(int.Parse(htmlColor.Replace("#", ""), NumberStyles.AllowHexSpecifier)); + } + + internal static SKColor FromArgb(int r, int g, int b) + { + return new SKColor(Convert.ToByte(r), Convert.ToByte(g), Convert.ToByte(b)); + } + + public static SKColor FromArgb(int argb) + { + return new SKColor((uint)argb); + } + + internal static SKColor FromArgb(int a, int r, int g, int b) + { + return new SKColor(Convert.ToByte(r), Convert.ToByte(g), Convert.ToByte(b), Convert.ToByte(a)); + } + + internal static SKColor FromName(string name) + { + var value = (SKColor)typeof(SKColors) + .GetFields(BindingFlags.Static | BindingFlags.Public).Single(color => color.Name == name).GetValue(null); - return ColorTranslator.FromHtml(htmlColor); - } - catch - { - // https://github.com/ClosedXML/ClosedXML/issues/675 - // When regional settings list separator is # , the standard ColorTranslator.FromHtml fails - return Color.FromArgb(int.Parse(htmlColor.Replace("#", ""), NumberStyles.AllowHexSpecifier)); - } + return value; } } } diff --git a/ClosedXML/Utils/CryptographicAlgorithms.cs b/ClosedXML/Utils/CryptographicAlgorithms.cs index 472d5de40..ff6856890 100644 --- a/ClosedXML/Utils/CryptographicAlgorithms.cs +++ b/ClosedXML/Utils/CryptographicAlgorithms.cs @@ -21,23 +21,34 @@ public static string Base64Encode(string plainText) return Convert.ToBase64String(plainTextBytes); } - public static String GenerateNewSalt(Algorithm algorithm) + public static string GenerateNewSalt(Algorithm algorithm) { if (RequiresSalt(algorithm)) + { return GetSalt(); + } else - return String.Empty; + { + return string.Empty; + } } - public static String GetPasswordHash(Algorithm algorithm, String password, String salt = "", UInt32 spinCount = 0) + public static string GetPasswordHash(Algorithm algorithm, string password, string salt = "", uint spinCount = 0) { if (password == null) + { throw new ArgumentNullException(nameof(password)); + } if (salt == null) + { throw new ArgumentNullException(nameof(salt)); + } - if ("" == password) return ""; + if (password?.Length == 0) + { + return ""; + } switch (algorithm) { @@ -54,15 +65,13 @@ public static String GetPasswordHash(Algorithm algorithm, String password, Strin public static string GetSalt(int length = 32) { - using (var random = new RNGCryptoServiceProvider()) - { - var salt = new byte[length]; - random.GetNonZeroBytes(salt); - return Convert.ToBase64String(salt); - } + using var random = new RNGCryptoServiceProvider(); + var salt = new byte[length]; + random.GetNonZeroBytes(salt); + return Convert.ToBase64String(salt); } - public static Boolean RequiresSalt(Algorithm algorithm) + public static bool RequiresSalt(Algorithm algorithm) { switch (algorithm) { @@ -77,19 +86,21 @@ public static Boolean RequiresSalt(Algorithm algorithm) } } - private static String GetDefaultPasswordHash(String password) + private static string GetDefaultPasswordHash(string password) { if (password == null) + { throw new ArgumentNullException(nameof(password)); + } // http://kohei.us/2008/01/18/excel-sheet-protection-password-hash/ // http://sc.openoffice.org/excelfileformat.pdf - 4.18.4 // http://web.archive.org/web/20080906232341/http://blogs.infosupport.com/wouterv/archive/2006/11/21/Hashing-password-for-use-in-SpreadsheetML.aspx - byte[] passwordCharacters = Encoding.ASCII.GetBytes(password); - int hash = 0; + var passwordCharacters = Encoding.ASCII.GetBytes(password); + var hash = 0; if (passwordCharacters.Length > 0) { - int charIndex = passwordCharacters.Length; + var charIndex = passwordCharacters.Length; while (charIndex-- > 0) { @@ -99,19 +110,23 @@ private static String GetDefaultPasswordHash(String password) // Main difference from spec, also hash with charcount hash = ((hash >> 14) & 0x01) | ((hash << 1) & 0x7fff); hash ^= passwordCharacters.Length; - hash ^= (0x8000 | ('N' << 8) | 'K'); + hash ^= 0x8000 | ('N' << 8) | 'K'; } return Convert.ToString(hash, 16).ToUpperInvariant(); } - private static String GetSha512PasswordHash(String password, String salt, UInt32 spinCount) + private static string GetSha512PasswordHash(string password, string salt, uint spinCount) { if (password == null) + { throw new ArgumentNullException(nameof(password)); + } if (salt == null) + { throw new ArgumentNullException(nameof(salt)); + } var saltBytes = Convert.FromBase64String(salt); var passwordBytes = Encoding.Unicode.GetBytes(password); diff --git a/ClosedXML/Utils/DescribedEnumParser.cs b/ClosedXML/Utils/DescribedEnumParser.cs index 838a76844..b2df10e6b 100644 --- a/ClosedXML/Utils/DescribedEnumParser.cs +++ b/ClosedXML/Utils/DescribedEnumParser.cs @@ -9,32 +9,32 @@ namespace ClosedXML.Utils { internal static class DescribedEnumParser { - private static Lazy> fromDescriptions = new Lazy>(() => + private static readonly Lazy> fromDescriptions = new Lazy>(() => { return ParseEnumDescriptions().ToDictionary(a => a.Item2, a => a.Item1); }); - private static Lazy> toDescriptions = new Lazy>(() => + private static readonly Lazy> toDescriptions = new Lazy>(() => { return ParseEnumDescriptions().ToDictionary(a => a.Item1, a => a.Item2); }); - public static T FromDescription(String value) + public static T FromDescription(string value) { return fromDescriptions.Value[value]; } - public static Boolean IsValidDescription(String value) + public static bool IsValidDescription(string value) { return fromDescriptions.Value.ContainsKey(value); } - public static String ToDescription(T value) + public static string ToDescription(T value) { return toDescriptions.Value[value]; } - private static IEnumerable> ParseEnumDescriptions() + private static IEnumerable> ParseEnumDescriptions() { var type = typeof(T); return type.GetFields(BindingFlags.Public | BindingFlags.Static) @@ -42,7 +42,7 @@ private static IEnumerable> ParseEnumDescriptions() { var attributes = f.GetCustomAttributes(typeof(DescriptionAttribute), inherit: false).OfType(); var description = attributes.FirstOrDefault()?.Description ?? f.Name; - return new Tuple + return new Tuple ( (T)Enum.Parse(type, f.Name), description diff --git a/ClosedXML/Utils/GraphicsUtils.cs b/ClosedXML/Utils/GraphicsUtils.cs index f0f764408..fb087a7bb 100644 --- a/ClosedXML/Utils/GraphicsUtils.cs +++ b/ClosedXML/Utils/GraphicsUtils.cs @@ -1,31 +1,18 @@ -using System; -using System.Drawing; +using SkiaSharp; namespace ClosedXML.Utils { internal static class GraphicsUtils { - [ThreadStatic] - private static Graphics threadLocalGraphics; - - internal static Graphics Graphics + internal static SKRect MeasureString(string text, SKFont font) { - get - { - if (threadLocalGraphics == null) - { - var image = new Bitmap(1, 1); - threadLocalGraphics = Graphics.FromImage(image); - } - return threadLocalGraphics; - } - } + using var paint = new SKPaint(); + paint.Typeface = font.Typeface; + paint.TextSize = font.Size; - private static StringFormat defaultStringFormat = StringFormat.GenericTypographic; - public static SizeF MeasureString(string s, Font font) - { - SizeF result = Graphics.MeasureString(s, font, Int32.MaxValue, defaultStringFormat); - return result; + var skBounds = SKRect.Empty; + paint.MeasureText(text, ref skBounds); + return skBounds; } } -} +} \ No newline at end of file diff --git a/ClosedXML/Utils/OpenXmlColorTypeAdapters.cs b/ClosedXML/Utils/OpenXmlColorTypeAdapters.cs index 3d22df4c1..5dd2962d8 100644 --- a/ClosedXML/Utils/OpenXmlColorTypeAdapters.cs +++ b/ClosedXML/Utils/OpenXmlColorTypeAdapters.cs @@ -18,7 +18,7 @@ internal class ColorTypeAdapter : IColorTypeAdapter { public ColorTypeAdapter(ColorType colorType) { - this.ColorType = colorType; + ColorType = colorType; } #region ColorType @@ -38,7 +38,7 @@ internal class X14ColorTypeAdapter : IColorTypeAdapter { public X14ColorTypeAdapter(X14.ColorType colorType) { - this.ColorType = colorType; + ColorType = colorType; } #region ColorType diff --git a/ClosedXML/Utils/OpenXmlHelper.cs b/ClosedXML/Utils/OpenXmlHelper.cs index 35cd2bed9..b0a6e6647 100644 --- a/ClosedXML/Utils/OpenXmlHelper.cs +++ b/ClosedXML/Utils/OpenXmlHelper.cs @@ -4,7 +4,6 @@ using DocumentFormat.OpenXml.Spreadsheet; using System; using System.Collections.Generic; -using Drawing = System.Drawing; using X14 = DocumentFormat.OpenXml.Office2010.Excel; namespace ClosedXML.Utils @@ -19,7 +18,7 @@ internal static class OpenXmlHelper /// The descendant of . /// The existing instance of ColorType. /// Color in ClosedXML format. - /// Flag specifiying that the color should be saved in + /// Flag specifying that the color should be saved in /// differential format (affects the transparent color processing). /// The original color in OpenXML format. public static T FromClosedXMLColor(this ColorType openXMLColor, XLColor xlColor, bool isDifferential = false) @@ -63,7 +62,7 @@ public static bool GetBooleanValueAsBool(BooleanValue value, bool defaultValue) /// Color in OpenXML format. /// The dictionary containing parsed colors to optimize performance. /// The color in ClosedXML format. - public static XLColor ToClosedXMLColor(this ColorType openXMLColor, IDictionary colorCache = null) + public static XLColor ToClosedXMLColor(this ColorType openXMLColor, IDictionary colorCache = null) { return ConvertToClosedXMLColor(new ColorTypeAdapter(openXMLColor), colorCache); } @@ -74,7 +73,7 @@ public static XLColor ToClosedXMLColor(this ColorType openXMLColor, IDictionary< /// Color in OpenXML format. /// The dictionary containing parsed colors to optimize performance. /// The color in ClosedXML format. - public static XLColor ToClosedXMLColor(this X14.ColorType openXMLColor, IDictionary colorCache = null) + public static XLColor ToClosedXMLColor(this X14.ColorType openXMLColor, IDictionary colorCache = null) { return ConvertToClosedXMLColor(new X14ColorTypeAdapter(openXMLColor), colorCache); } @@ -90,24 +89,27 @@ public static XLColor ToClosedXMLColor(this X14.ColorType openXMLColor, IDiction /// Since these types do not implement a common interface we use dynamic. /// The dictionary containing parsed colors to optimize performance. /// The color in ClosedXML format. - private static XLColor ConvertToClosedXMLColor(IColorTypeAdapter openXMLColor, IDictionary colorCache ) + private static XLColor ConvertToClosedXMLColor(IColorTypeAdapter openXMLColor, IDictionary colorCache) { XLColor retVal = null; if (openXMLColor != null) { if (openXMLColor.Rgb != null) { - String htmlColor = "#" + openXMLColor.Rgb.Value; - if (colorCache == null || !colorCache.TryGetValue(htmlColor, out Drawing.Color thisColor)) + var htmlColor = "#" + openXMLColor.Rgb.Value; + if (colorCache == null || !colorCache.TryGetValue(htmlColor, out var thisColor)) { - thisColor = ColorStringParser.ParseFromHtml(htmlColor); + var sKColor = ColorStringParser.ParseFromHtml(htmlColor); + thisColor = sKColor.ConvertToOpenXmlColor(); colorCache?.Add(htmlColor, thisColor); } retVal = XLColor.FromColor(thisColor); } else if (openXMLColor.Indexed != null && openXMLColor.Indexed <= 64) - retVal = XLColor.FromIndex((Int32)openXMLColor.Indexed.Value); + { + retVal = XLColor.FromIndex((int)openXMLColor.Indexed.Value); + } else if (openXMLColor.Theme != null) { retVal = openXMLColor.Tint != null @@ -130,10 +132,14 @@ private static XLColor ConvertToClosedXMLColor(IColorTypeAdapter openXMLColor, I private static void FillFromClosedXMLColor(IColorTypeAdapter openXMLColor, XLColor xlColor, bool isDifferential) { if (openXMLColor == null) + { throw new ArgumentNullException(nameof(openXMLColor)); + } if (xlColor == null) + { throw new ArgumentNullException(nameof(xlColor)); + } switch (xlColor.ColorType) { @@ -144,14 +150,20 @@ private static void FillFromClosedXMLColor(IColorTypeAdapter openXMLColor, XLCol case XLColorType.Indexed: // 64 is 'transparent' and should be ignored for differential formats if (!isDifferential || xlColor.Indexed != 64) - openXMLColor.Indexed = (UInt32)xlColor.Indexed; + { + openXMLColor.Indexed = (uint)xlColor.Indexed; + } + break; case XLColorType.Theme: - openXMLColor.Theme = (UInt32)xlColor.ThemeColor; + openXMLColor.Theme = (uint)xlColor.ThemeColor; if (xlColor.ThemeTint != 0) + { openXMLColor.Tint = xlColor.ThemeTint; + } + break; } } diff --git a/ClosedXML/Utils/XmlEncoder.cs b/ClosedXML/Utils/XmlEncoder.cs index 866852ffa..d5d73bdac 100644 --- a/ClosedXML/Utils/XmlEncoder.cs +++ b/ClosedXML/Utils/XmlEncoder.cs @@ -11,7 +11,10 @@ public static class XmlEncoder public static string EncodeString(string encodeStr) { - if (encodeStr == null) return null; + if (encodeStr == null) + { + return null; + } encodeStr = xHHHHRegex.Replace(encodeStr, "_x005F_$1_"); @@ -34,7 +37,10 @@ public static string EncodeString(string encodeStr) public static string DecodeString(string decodeStr) { - if (string.IsNullOrEmpty(decodeStr)) return string.Empty; + if (string.IsNullOrEmpty(decodeStr)) + { + return string.Empty; + } // Strings "escaped" with _X (capital X) should not be treated as escaped // Example: _Xceed_Something diff --git a/ClosedXML/XLHelper.cs b/ClosedXML/XLHelper.cs index 412311652..6f456692a 100644 --- a/ClosedXML/XLHelper.cs +++ b/ClosedXML/XLHelper.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Drawing; using System.Globalization; using System.Linq; using System.Text.RegularExpressions; @@ -16,16 +15,12 @@ public static partial class XLHelper public const int MinColumnNumber = 1; public const int MaxRowNumber = 1048576; public const int MaxColumnNumber = 16384; - public const String MaxColumnLetter = "XFD"; - public const Double Epsilon = 1e-10; + public static readonly string MaxColumnLetter = "XFD"; + public static readonly double Epsilon = 1e-10; - public static String LastCell { get { return $"{MaxColumnLetter}{MaxRowNumber}"; } } + public static string LastCell => $"{MaxColumnLetter}{MaxRowNumber}"; - private static readonly Lazy graphics = new Lazy(() => Graphics.FromImage(new Bitmap(200, 200))); - internal static Graphics Graphics { get => graphics.Value; } - internal static Double DpiX { get => Graphics.DpiX; } - - internal static readonly NumberStyles NumberStyle = NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite | NumberStyles.AllowExponent; + internal const NumberStyles NumberStyle = NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite | NumberStyles.AllowExponent; internal static readonly CultureInfo ParseCulture = CultureInfo.InvariantCulture; internal static readonly Regex RCSimpleRegex = new Regex( @@ -67,17 +62,24 @@ public static partial class XLHelper static XLHelper() { - allLetters = new string[XLHelper.MaxColumnNumber]; - letterIndexes = new Dictionary(XLHelper.MaxColumnNumber, StringComparer.Create(ParseCulture, true)); - for (int i = 0; i < XLHelper.MaxColumnNumber; i++) + allLetters = new string[MaxColumnNumber]; + letterIndexes = new Dictionary(MaxColumnNumber, StringComparer.Create(ParseCulture, true)); + for (var i = 0; i < MaxColumnNumber; i++) { string letter; if (i < 26) + { letter = letters[i]; + } else if (i < 26 * 27) + { letter = letters[i / 26 - 1] + letters[i % 26]; + } else + { letter = letters[(i - 26) / 26 / 26 - 1] + letters[(i / 26 - 1) % 26] + letters[i % 26]; + } + allLetters[i] = letter; letterIndexes.Add(letter, i + 1); } @@ -89,16 +91,21 @@ static XLHelper() /// The column letter to translate into a column number. public static int GetColumnNumberFromLetter(string columnLetter) { - if (string.IsNullOrEmpty(columnLetter)) throw new ArgumentNullException("columnLetter"); + if (string.IsNullOrEmpty(columnLetter)) + { + throw new ArgumentNullException(nameof(columnLetter)); + } //Extra check because we allow users to pass row col positions in as strings if (columnLetter[0] <= '9') { - return Int32.Parse(columnLetter, XLHelper.NumberStyle, XLHelper.ParseCulture); + return int.Parse(columnLetter, NumberStyle, ParseCulture); } if (letterIndexes.TryGetValue(columnLetter, out var retVal)) + { return retVal; + } throw new ArgumentOutOfRangeException(columnLetter + " is not recognized as a column letter"); } @@ -111,10 +118,15 @@ public static int GetColumnNumberFromLetter(string columnLetter) /// public static string GetColumnLetterFromNumber(int columnNumber, bool trimToAllowed = false) { - if (trimToAllowed) columnNumber = TrimColumnNumber(columnNumber); + if (trimToAllowed) + { + columnNumber = TrimColumnNumber(columnNumber); + } if (columnNumber <= 0 || columnNumber > allLetters.Length) + { throw new ArgumentOutOfRangeException(nameof(columnNumber)); + } // Adjust for start on column 1 return allLetters[columnNumber - 1]; @@ -122,62 +134,88 @@ public static string GetColumnLetterFromNumber(int columnNumber, bool trimToAllo internal static int TrimColumnNumber(int columnNumber) { - return Math.Max(XLHelper.MinColumnNumber, Math.Min(XLHelper.MaxColumnNumber, columnNumber)); + return Math.Max(MinColumnNumber, Math.Min(MaxColumnNumber, columnNumber)); } internal static int TrimRowNumber(int rowNumber) { - return Math.Max(XLHelper.MinRowNumber, Math.Min(XLHelper.MaxRowNumber, rowNumber)); + return Math.Max(MinRowNumber, Math.Min(MaxRowNumber, rowNumber)); } public static bool IsValidColumn(string column) { - if (String.IsNullOrWhiteSpace(column)) + if (string.IsNullOrWhiteSpace(column)) + { return false; + } + var length = column.Length; if (length > 3) + { return false; + } var theColumn = column.ToUpper(); var isValid = theColumn[0] >= 'A' && theColumn[0] <= 'Z'; if (length == 1) + { return isValid; + } if (length == 2) + { return isValid && theColumn[1] >= 'A' && theColumn[1] <= 'Z'; + } if (theColumn[0] >= 'A' && theColumn[0] < 'X') + { return theColumn[1] >= 'A' && theColumn[1] <= 'Z' && theColumn[2] >= 'A' && theColumn[2] <= 'Z'; + } - if (theColumn[0] != 'X') return false; + if (theColumn[0] != 'X') + { + return false; + } if (theColumn[1] < 'F') + { return theColumn[2] >= 'A' && theColumn[2] <= 'Z'; + } - if (theColumn[1] != 'F') return false; + if (theColumn[1] != 'F') + { + return false; + } return theColumn[2] >= 'A' && theColumn[2] <= 'D'; } public static bool IsValidRow(string rowString) { - if (Int32.TryParse(rowString, out int row)) + if (int.TryParse(rowString, out var row)) + { return row > 0 && row <= MaxRowNumber; + } + return false; } public static bool IsValidA1Address(string address) { - if (String.IsNullOrWhiteSpace(address)) + if (string.IsNullOrWhiteSpace(address)) + { return false; + } address = address.Replace("$", ""); var rowPos = 0; var addressLength = address.Length; while (rowPos < addressLength && (address[rowPos] > '9' || address[rowPos] < '0')) + { rowPos++; + } return rowPos < addressLength @@ -187,18 +225,20 @@ public static bool IsValidA1Address(string address) public static bool IsValidRCAddress(string address) { - if (String.IsNullOrWhiteSpace(address)) + if (string.IsNullOrWhiteSpace(address)) + { return false; + } return RCSimpleRegex.IsMatch(address); } - public static Boolean IsValidRangeAddress(String rangeAddress) + public static bool IsValidRangeAddress(string rangeAddress) { return A1SimpleRegex.IsMatch(rangeAddress); } - public static Boolean IsValidRangeAddress(IXLRangeAddress rangeAddress) + public static bool IsValidRangeAddress(IXLRangeAddress rangeAddress) { return rangeAddress.IsValid && rangeAddress.FirstAddress.RowNumber >= 1 && rangeAddress.LastAddress.RowNumber <= MaxRowNumber @@ -211,7 +251,9 @@ public static int GetColumnNumberFromAddress(string cellAddressString) { var rowPos = 0; while (cellAddressString[rowPos] > '9') + { rowPos++; + } return GetColumnNumberFromLetter(cellAddressString.Substring(0, rowPos)); } @@ -221,19 +263,19 @@ internal static string[] SplitRange(string range) return range.Contains('-') ? range.Replace('-', ':').Split(':') : range.Split(':'); } - public static Int32 GetPtFromPx(Double px) + public static int GetPtFromPx(double px) { - return Convert.ToInt32(px * 72.0 / DpiX); + return Convert.ToInt32(px * 72.0); } - public static Double GetPxFromPt(Int32 pt) + public static double GetPxFromPt(int pt) { - return Convert.ToDouble(pt) * DpiX / 72.0; + return Convert.ToDouble(pt) / 72.0; } internal static IXLTableRows InsertRowsWithoutEvents(Func insertFunc, - XLTableRange tableRange, Int32 numberOfRows, - Boolean expandTable) + XLTableRange tableRange, int numberOfRows, + bool expandTable) { var ws = tableRange.Worksheet; var tracking = ws.EventTrackingEnabled; @@ -244,7 +286,9 @@ internal static IXLTableRows InsertRowsWithoutEvents(Func rows.Add(new XLTableRow(tableRange, r as XLRangeRow))); if (expandTable) + { tableRange.Table.ExpandTableRows(numberOfRows); + } ws.EventTrackingEnabled = tracking; @@ -269,59 +313,70 @@ public static bool IsNullOrWhiteSpace(string value) + @"|(?<=\W)(?\$?\d{1,7}:\$?\d{1,7})(?=\W)" // 1:1 + @"|(?<=\W)(?\$?[a-zA-Z]{1,3}:\$?[a-zA-Z]{1,3})(?=\W)", RegexOptions.Compiled); // A:A - private static string Evaluator(Match match, Int32 row, String column) + private static string Evaluator(Match match, int row, string column) { if (match.Groups["one"].Success) { var split = match.Groups["one"].Value.Split('$'); - if (split.Length == 1) return column + row; // A1 - if (split.Length == 3) return match.Groups["one"].Value; // $A$1 + if (split.Length == 1) + { + return column + row; // A1 + } + + if (split.Length == 3) + { + return match.Groups["one"].Value; // $A$1 + } + var a = XLAddress.Create(match.Groups["one"].Value); - if (split[0].Length == 0) return "$" + a.ColumnLetter + row; // $A1 + if (split[0].Length == 0) + { + return "$" + a.ColumnLetter + row; // $A1 + } + return column + "$" + a.RowNumber; } if (match.Groups["two"].Success) + { return ReplaceGroup(match.Groups["two"].Value, row.ToString()); + } return ReplaceGroup(match.Groups["three"].Value, column); } - private static String ReplaceGroup(String value, String item) + private static string ReplaceGroup(string value, string item) { var split = value.Split(':'); - String ret1 = split[0].StartsWith("$") ? split[0] : item; - String ret2 = split[1].StartsWith("$") ? split[1] : item; + var ret1 = split[0].StartsWith("$") ? split[0] : item; + var ret2 = split[1].StartsWith("$") ? split[1] : item; return ret1 + ":" + ret2; } - internal static String ReplaceRelative(String value, Int32 row, String column) + internal static string ReplaceRelative(string value, int row, string column) { var oldValue = ">" + value + "<"; var newVal = A1RegexRelative.Replace(oldValue, m => Evaluator(m, row, column)); return newVal.Substring(1, newVal.Length - 2); } - public static Boolean AreEqual(Double d1, Double d2) + public static bool AreEqual(double d1, double d2) { return Math.Abs(d1 - d2) < Epsilon; } - public static DateTime GetDate(Object v) + public static DateTime GetDate(object v) { - // handle dates - if (v is DateTime) + if (v is DateTime time) { - return (DateTime)v; + return time; } - // handle doubles - if (v is double && ((double)v).IsValidOADateNumber()) + if (v is double @double && @double.IsValidOADateNumber()) { - return DateTime.FromOADate((double)v); + return DateTime.FromOADate(@double); } - // handle everything else return (DateTime)Convert.ChangeType(v, typeof(DateTime)); } @@ -342,10 +397,10 @@ internal static TimeSpan GetTimeSpan(double totalDays) return TimeSpan.FromMilliseconds(roundedMilliseconds); } - public static Boolean ValidateName(String objectType, String newName, String oldName, IEnumerable existingNames, out String message) + public static bool ValidateName(string objectType, string newName, string oldName, IEnumerable existingNames, out string message) { message = ""; - if (String.IsNullOrWhiteSpace(newName)) + if (string.IsNullOrWhiteSpace(newName)) { message = $"The {objectType} name '{newName}' is invalid"; return false; @@ -381,4 +436,4 @@ public static Boolean ValidateName(String objectType, String newName, String old return true; } } -} +} \ No newline at end of file diff --git a/ClosedXML/XLHelper_ASF.cs b/ClosedXML/XLHelper_ASF.cs index 7037c8218..629fff4c6 100644 --- a/ClosedXML/XLHelper_ASF.cs +++ b/ClosedXML/XLHelper_ASF.cs @@ -41,7 +41,9 @@ public static partial class XLHelper public static string CreateSafeSheetName(string nameProposal, char replaceChar = ' ') { if (illegalWorksheetCharacters.Contains(replaceChar) || replaceChar == '\'') + { throw new ArgumentException("Invalid replacement character.", nameof(replaceChar)); + } if (nameProposal == null) { @@ -51,17 +53,21 @@ public static string CreateSafeSheetName(string nameProposal, char replaceChar = { return "empty"; } - int length = Math.Min(MaxWorksheetNameCharsCount, nameProposal.Length); + var length = Math.Min(MaxWorksheetNameCharsCount, nameProposal.Length); var shortenedName = nameProposal.Substring(0, length); var result = new System.Text.StringBuilder(shortenedName); - for (int i = 0; i < length; i++) + for (var i = 0; i < length; i++) { - char ch = result[i]; + var ch = result[i]; if (illegalWorksheetCharacters.Contains(result[i])) + { result[i] = replaceChar; + } if (ch == '\'' && (i == 0 || i == length - 1)) + { result[i] = replaceChar; + } } return result.ToString(); } @@ -86,23 +92,25 @@ public static string CreateSafeSheetName(string nameProposal, char replaceChar = /// /// // This method was ported from the POI project at https://github.com/apache/poi/blob/trunk/src/java/org/apache/poi/ss/util/WorkbookUtil.java - public static void ValidateSheetName(String sheetName) + public static void ValidateSheetName(string sheetName) { - if (String.IsNullOrWhiteSpace(sheetName)) + if (string.IsNullOrWhiteSpace(sheetName)) { throw new ArgumentException("sheetName must not be null or whitespace"); } - int len = sheetName.Length; + var len = sheetName.Length; if (len < 1 || len > MaxWorksheetNameCharsCount) { throw new ArgumentException($"sheetName '{sheetName}' is invalid - character count MUST be greater than or equal to 1 and less than or equal to {MaxWorksheetNameCharsCount}"); } - for (int i = 0; i < len; i++) + for (var i = 0; i < len; i++) { if (illegalWorksheetCharacters.Contains(sheetName[i])) + { throw new ArgumentException($"Invalid char ({sheetName[i]}) found at index ({i}) in sheet name '{sheetName}'"); + } } if (sheetName[0] == '\'' || sheetName[len - 1] == '\'') { diff --git a/ClosedXML/docs/nugetReadme.md b/ClosedXML/docs/nugetReadme.md new file mode 100644 index 000000000..9d1dcbfef --- /dev/null +++ b/ClosedXML/docs/nugetReadme.md @@ -0,0 +1,13 @@ +ClosedXML allows you to create Excel files without the Excel application. + +Example: + +```csharp +using (var workbook = new XLWorkbook()) +{ + var worksheet = workbook.Worksheets.Add("Sample Sheet"); + worksheet.Cell("A1").Value = "Hello World!"; + worksheet.Cell("A2").FormulaA1 = "=MID(A1, 7, 5)"; + workbook.SaveAs("HelloWorld.xlsx"); +} +``` diff --git a/ClosedXML_Sandbox/Properties/launchSettings.json b/ClosedXML_Sandbox/Properties/launchSettings.json new file mode 100644 index 000000000..817fbac08 --- /dev/null +++ b/ClosedXML_Sandbox/Properties/launchSettings.json @@ -0,0 +1,12 @@ +{ + "profiles": { + "ClosedXML_Sandbox": { + "commandName": "Project" + }, + "WSL": { + "commandName": "WSL2", + "environmentVariables": {}, + "distributionName": "" + } + } +} \ No newline at end of file diff --git a/README.md b/README.md index fc46f4103..b685c203d 100644 --- a/README.md +++ b/README.md @@ -1,29 +1,27 @@ -![ClosedXML](https://github.com/ClosedXML/ClosedXML/blob/develop/resources/logo/readme.png) +# ClosedXML -[![Release](https://img.shields.io/badge/release-0.95.4-blue.svg)](https://github.com/ClosedXML/ClosedXML/releases/latest) [![NuGet Badge](https://buildstats.info/nuget/ClosedXML)](https://www.nuget.org/packages/ClosedXML/) [![.NET Framework](https://img.shields.io/badge/.NET%20Framework-%3E%3D%204.0-red.svg)](#) [![.NET Standard](https://img.shields.io/badge/.NET%20Standard-%3E%3D%202.0-red.svg)](#) [![Build status](https://ci.appveyor.com/api/projects/status/wobbmnlbukxejjgb?svg=true)](https://ci.appveyor.com/project/ClosedXML/ClosedXML/branch/develop/artifacts) -[![Open Source Helpers](https://www.codetriage.com/closedxml/closedxml/badges/users.svg)](https://www.codetriage.com/closedxml/closedxml) - -[💾 Download unstable CI build](https://ci.appveyor.com/project/ClosedXML/ClosedXML/branch/develop/artifacts) +[![.NET build and test](https://github.com/rubicon-oss/DocumentPartner.ClosedXML/actions/workflows/dotnet.yml/badge.svg)](https://github.com/rubicon-oss/DocumentPartner.ClosedXML/actions/workflows/dotnet.yml) [![NuGet Badge](https://buildstats.info/nuget/DocumentPartner.ClosedXML)](https://www.nuget.org/packages/DocumentPartner.ClosedXML/) ClosedXML is a .NET library for reading, manipulating and writing Excel 2007+ (.xlsx, .xlsm) files. It aims to provide an intuitive and user-friendly interface to dealing with the underlying [OpenXML](https://github.com/OfficeDev/Open-XML-SDK) API. -[For more information see the wiki](https://github.com/closedxml/closedxml/wiki) +This fork of [ClosedXML](https://www.nuget.org/packages/ClosedXML/) adds Linux and MacOs support. -### Install ClosedXML via NuGet +[For more information see the wiki](https://github.com/closedxml/closedxml/wiki) -If you want to include ClosedXML in your project, you can [install it directly from NuGet](https://www.nuget.org/packages/ClosedXML) +## Install ClosedXML via NuGet To install ClosedXML, run the following command in the Package Manager Console -``` -PM> Install-Package ClosedXML +``` powershell +PM> Install-Package DocumentPartner.ClosedXML ``` -### What can you do with this? +## What can you do with this? ClosedXML allows you to create Excel files without the Excel application. The typical example is creating Excel reports on a web server. **Example:** + ```c# using (var workbook = new XLWorkbook()) { @@ -35,23 +33,11 @@ using (var workbook = new XLWorkbook()) ``` ### Frequent answers -- ClosedXML is not thread-safe. There is no guarantee that [parallel operations](https://github.com/ClosedXML/ClosedXML/issues/1662) will work. The underlying OpenXML library is also not thread-safe. -- If you get an exception `The type initializer for 'Gdip' threw an exception.` on Linux, try [these](https://stackoverflow.com/a/67092403/179494) [solutions](https://github.com/dotnet/runtime/issues/27200#issuecomment-415327256). -### Extensions -Be sure to check out our `ClosedXML` extension projects -- https://github.com/ClosedXML/ClosedXML.Report -- https://github.com/ClosedXML/ClosedXML.Extensions.AspNet -- https://github.com/ClosedXML/ClosedXML.Extensions.Mvc -- https://github.com/ClosedXML/ClosedXML.Extensions.WebApi +- ClosedXML is not thread-safe. There is no guarantee that [parallel operations](https://github.com/ClosedXML/ClosedXML/issues/1662) will work. The underlying OpenXML library is also not thread-safe. ## Developer guidelines + The [OpenXML specification](https://www.ecma-international.org/publications/standards/Ecma-376.htm) is a large and complicated beast. In order for ClosedXML, the wrapper around OpenXML, to support all the features, we rely on community contributions. Before opening an issue to request a new feature, we'd like to urge you to try to implement it yourself and log a pull request. Please read the [full developer guidelines](CONTRIBUTING.md). - -## Credits -* Project originally created by Manuel de Leon -* Current maintainer: [Francois Botha](https://github.com/igitur) -* Master of Computing Patterns: [Aleksei Pankratev](https://github.com/Pankraty) -* Logo design by [@Tobaloidee](https://github.com/Tobaloidee) diff --git a/appveyor.yml b/appveyor.yml deleted file mode 100644 index 0b154af95..000000000 --- a/appveyor.yml +++ /dev/null @@ -1,60 +0,0 @@ -version: 0.95.4.{build} - -os: Visual Studio 2019 -image: Visual Studio 2019 - -environment: - AppVeyor: APPVEYOR - -init: - -- ps: >- - if ($env:APPVEYOR_REPO_TAG -eq 'true') - { - $env:fileVersion = $env:APPVEYOR_REPO_TAG_NAME -replace '(\d+)\.(\d+)\.(\d+)(-.+)?', '$1.$2.$3' - if ($env:fileVersion -eq $env:APPVEYOR_REPO_TAG_NAME) { $env:fileVersion = $($env:fileVersion + '.0') } - else { $env:fileVersion = $($env:fileVersion + '.' + $env:APPVEYOR_BUILD_NUMBER) } - $env:productVersion = $env:APPVEYOR_REPO_TAG_NAME - } - else - { - $env:fileVersion = $env:APPVEYOR_BUILD_VERSION -replace '(\d+)\.(\d+)\.([^.]+)\.(\d+)', '$1.$2.999.$4' - $env:productVersion = $env:fileVersion - } - - Update-AppveyorBuild -Version $env:fileVersion - - Write-Host $env:fileVersion $env:productVersion - - Write-Host $env:APPVEYOR_REPO_TAG $env:APPVEYOR_REPO_TAG_NAME - - -dotnet_csproj: - patch: true - file: '**\*.csproj' - version: '$(productVersion)' - package_version: '$(productVersion)' - assembly_version: '$(fileVersion)' - file_version: '$(fileVersion)' - informational_version: '$(productVersion)' - -# platform: Any CPU -configuration : -- Release - -before_build: - - cmd: nuget update -self - - nuget restore - -build: - parallel: true - project: ClosedXML.sln - verbosity: minimal - -artifacts: - - path: ClosedXML/bin/%CONFIGURATION%/*/ClosedXML.dll - - path: ClosedXML/bin/%CONFIGURATION%/*.nupkg - -nuget: - project_feed: true - disable_publish_on_pr: true diff --git a/testenvironments.json b/testenvironments.json new file mode 100644 index 000000000..539ead6b0 --- /dev/null +++ b/testenvironments.json @@ -0,0 +1,10 @@ +{ + "version": "1", + "environments": [ + { + "name": "Ubuntu", + "type": "wsl", + "wslDistribution": "Ubuntu" + } + ] +}