diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelElement.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelElement.cs
index 51d2906..45e474b 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelElement.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelElement.cs
@@ -21,8 +21,7 @@ public interface IExcelElement<TOpenXmlElement> : IMetadataProvider
         /// <summary>
         /// Gets OpenXml element.
         /// </summary>
-        [MaybeNull]
-        TOpenXmlElement Data { get; }
+        TOpenXmlElement? Data { get; }
 
         /// <summary>
         /// Returns true if <see cref="Data"/> is not null.
@@ -45,21 +44,14 @@ public class ExcelElement<TOpenXmlElement> : IExcelElement<TOpenXmlElement>
         /// <summary>
         /// Gets OpenXml element.
         /// </summary>
-        [MaybeNull]
-        public TOpenXmlElement Data { get; }
-
-        ///// <summary>
-        ///// Gets OpenXml element as <see cref="Option{A}"/>.
-        ///// </summary>
-        ///// <returns>Optional OpenXml element.</returns>
-        //public Option<TOpenXmlElement> AsOption() => Data!;
+        public TOpenXmlElement? Data { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ExcelElement{TOpenXmlElement}"/> class.
         /// </summary>
         /// <param name="doc">OpenXml document that contains this element.</param>
         /// <param name="data">OpenXml element.</param>
-        public ExcelElement(SpreadsheetDocument doc, [MaybeNull] TOpenXmlElement data)
+        public ExcelElement(SpreadsheetDocument doc, TOpenXmlElement? data)
         {
             Doc = doc.AssertArgumentNotNull(nameof(doc));
             Data = data;
@@ -95,15 +87,14 @@ public ExcelElement(SpreadsheetDocument doc, [MaybeNull] TOpenXmlElement data)
         /// <summary>
         /// Gets OpenXml element.
         /// </summary>
-        [MaybeNull]
-        public TOpenXmlElement Data { get; }
+        public TOpenXmlElement? Data { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ExcelElementLight{TOpenXmlElement}"/> struct.
         /// </summary>
         /// <param name="doc">OpenXml document that contains this element.</param>
         /// <param name="data">OpenXml element.</param>
-        public ExcelElementLight(SpreadsheetDocument doc, [MaybeNull] TOpenXmlElement data)
+        public ExcelElementLight(SpreadsheetDocument doc, TOpenXmlElement? data)
         {
             Doc = doc.AssertArgumentNotNull(nameof(doc));
             Data = data;
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsing.CellReference.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsing.CellReference.cs
new file mode 100644
index 0000000..048adef
--- /dev/null
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsing.CellReference.cs
@@ -0,0 +1,75 @@
+// Copyright (c) MicroElements. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Linq;
+using DocumentFormat.OpenXml;
+using MicroElements.CodeContracts;
+using MicroElements.Collections.Cache;
+
+namespace MicroElements.Metadata.OpenXml.Excel.Parsing
+{
+    public static partial class ExcelParsingExtensions
+    {
+        /// <summary>
+        /// Gets cell reference by column row index.
+        /// Example: (0,0)->A1.
+        /// </summary>
+        /// <param name="column">Column index.</param>
+        /// <param name="row">Row index.</param>
+        /// <param name="zeroBased">Is column and row zero based.</param>
+        /// <returns>Cell reference.</returns>
+        public static StringValue GetCellReference(int column, int row, bool zeroBased = true)
+        {
+            int columnIndex = zeroBased ? column : column - 1;
+            string columnName = GetColumnName(columnIndex);
+            int rowName = zeroBased ? row + 1 : row;
+            return new StringValue(string.Concat(columnName, rowName.ToString()));
+        }
+
+        /// <summary>
+        /// Gets column index (cached).
+        /// </summary>
+        public static string GetColumnName(int columnIndex = 0)
+        {
+            return Cache
+                .Instance<int, string>("ColumnName")
+                .GetOrAdd(columnIndex, i => GetColumnName(string.Empty, i));
+        }
+
+        private static string GetColumnName(string prefix, int columnIndex = 0)
+        {
+            return columnIndex < 26
+                ? $"{prefix}{(char)(65 + columnIndex)}"
+                : GetColumnName(GetColumnName(prefix, ((columnIndex - (columnIndex % 26)) / 26) - 1), columnIndex % 26);
+        }
+
+        /// <summary>
+        /// Gets column reference from cell reference.
+        /// For example: A1->A, CD22->CD.
+        /// </summary>
+        /// <param name="cellReference">Cell reference.</param>
+        /// <returns>Column reference.</returns>
+        public static string GetColumnReference(this StringValue cellReference)
+        {
+            cellReference.AssertArgumentNotNull(nameof(cellReference));
+
+            return cellReference.Value.GetColumnReference();
+        }
+
+        /// <summary>
+        /// Gets column reference from cell reference.
+        /// For example: A1->A, CD22->CD.
+        /// </summary>
+        /// <param name="cellReference">Cell reference.</param>
+        /// <returns>Column reference.</returns>
+        public static string GetColumnReference(this string cellReference)
+        {
+            cellReference.AssertArgumentNotNull(nameof(cellReference));
+
+            if (cellReference.Length == 2)
+                return cellReference.Substring(0, 1);
+
+            return new string(cellReference.TakeWhile(char.IsLetter).ToArray());
+        }
+    }
+}
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsingExtensions.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsingExtensions.cs
index cf3fcf0..ee5f02a 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsingExtensions.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Parsing/ExcelParsingExtensions.cs
@@ -10,7 +10,9 @@
 using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Spreadsheet;
 using MicroElements.CodeContracts;
+using MicroElements.Collections.Cache;
 using MicroElements.Collections.Extensions.Iterate;
+using MicroElements.Collections.TwoLayerCache;
 using MicroElements.Diagnostics;
 using MicroElements.Metadata.Parsing;
 using MicroElements.Validation;
@@ -64,17 +66,6 @@ public static IEnumerable<ExcelElement<Column>> GetColumns(this ExcelElement<She
             return Array.Empty<ExcelElement<Column>>();
         }
 
-        /// <summary>
-        /// Gets rows from sheet.
-        /// </summary>
-        /// <param name="sheet">Source sheet.</param>
-        /// <returns>Sheet rows.</returns>
-        public static IEnumerable<ExcelElement<Row>> GetRows(this ExcelElement<Sheet> sheet)
-        {
-            return GetOpenXmlRows(sheet)
-                .Zip(Enumerable.Repeat(sheet, int.MaxValue), (row, sh) => new ExcelElement<Row>(sh.Doc, row));
-        }
-
         /// <summary>
         /// Gets rows from sheet.
         /// </summary>
@@ -96,65 +87,13 @@ public static IEnumerable<Row> GetOpenXmlRows(this ExcelElement<Sheet> sheet)
         }
 
         /// <summary>
-        /// Gets cell reference by column row index.
-        /// Example: (0,0)->A1.
-        /// </summary>
-        /// <param name="column">Column index.</param>
-        /// <param name="row">Row index.</param>
-        /// <param name="zeroBased">Is column and row zero based.</param>
-        /// <returns>Cell reference.</returns>
-        public static StringValue GetCellReference(int column, int row, bool zeroBased = true)
-        {
-            int columnIndex = zeroBased ? column : column - 1;
-            string columnName = GetColumnName(columnIndex);
-            int rowName = zeroBased ? row + 1 : row;
-            return new StringValue(string.Concat(columnName, rowName.ToString()));
-        }
-
-        private static readonly ConcurrentDictionary<int, string> _columnIndexes = new ConcurrentDictionary<int, string>();
-
-        /// <summary>
-        /// Gets column index (cached).
-        /// </summary>
-        public static string GetColumnName(int columnIndex = 0)
-        {
-            return _columnIndexes.GetOrAdd(columnIndex, i => GetColumnName(string.Empty, i));
-        }
-
-        private static string GetColumnName(string prefix, int columnIndex = 0)
-        {
-            return columnIndex < 26
-                ? $"{prefix}{(char)(65 + columnIndex)}"
-                : GetColumnName(GetColumnName(prefix, ((columnIndex - (columnIndex % 26)) / 26) - 1), columnIndex % 26);
-        }
-
-        /// <summary>
-        /// Gets column reference from cell reference.
-        /// For example: A1->A, CD22->CD.
-        /// </summary>
-        /// <param name="cellReference">Cell reference.</param>
-        /// <returns>Column reference.</returns>
-        public static string GetColumnReference(this StringValue cellReference)
-        {
-            cellReference.AssertArgumentNotNull(nameof(cellReference));
-
-            return cellReference.Value.GetColumnReference();
-        }
-
-        /// <summary>
-        /// Gets column reference from cell reference.
-        /// For example: A1->A, CD22->CD.
+        /// Gets rows from sheet.
         /// </summary>
-        /// <param name="cellReference">Cell reference.</param>
-        /// <returns>Column reference.</returns>
-        public static string GetColumnReference(this string cellReference)
+        /// <param name="sheet">Source sheet.</param>
+        /// <returns>Sheet rows.</returns>
+        public static IEnumerable<ExcelElement<Row>> GetRows(this ExcelElement<Sheet> sheet)
         {
-            cellReference.AssertArgumentNotNull(nameof(cellReference));
-
-            if (cellReference.Length == 2)
-                return cellReference.Substring(0, 1);
-
-            return new string(cellReference.TakeWhile(char.IsLetter).ToArray());
+            return GetOpenXmlRows(sheet).Select(row => new ExcelElement<Row>(sheet.Doc, row));
         }
 
         /// <summary>
@@ -253,7 +192,7 @@ public static ExcelElement<HeaderCell>[] GetHeaders(this ExcelElement<Row> row)
                 if (cell != null)
                 {
                     IPropertyParser? propertyParser = header.GetMetadata<IPropertyParser>();
-                    rowValues[i] = cell.GetCellValue(nullValue, propertyParser);
+                    rowValues[i] = cell.GetCellValue(nullValue, propertyParser?.TargetType);
 
                     //StringValue cellReference = cell.Data.CellReference;
                 }
@@ -309,28 +248,37 @@ private static string GetFormattedValue(this ExcelElement<Cell> cell)
         /// Uses SharedStringTable if needed.
         /// For DateTime, LocalDate and LocalTime tries to convert double excel value to ISO format.
         /// </summary>
-        public static string? GetCellValue(this ExcelElement<Cell> cell, string? nullValue = null, IPropertyParser? propertyParser = null)
+        public static string? GetCellValue<T>(
+            this T cellElement,
+            string? nullValue = null,
+            Type? targetType = null)
+            where T : IExcelElement<Cell>
         {
-            Cell? cellData = cell.Data;
-            string? cellValue = cellData?.CellValue?.InnerText ?? nullValue;
+            Cell? cell = cellElement.Data;
+            SharedStringTable sharedStringTable = cellElement.Doc.WorkbookPart.SharedStringTablePart.SharedStringTable;
+
+            string? cellValue = cell?.CellValue?.InnerText ?? nullValue;
             string? cellTextValue = null;
 
-            if (cellData == null)
+            if (cell == null)
                 return cellValue;
 
-            CellValues? dataTypeValue = cellData.DataType?.Value;
+            CellValues? dataTypeValue = cell.DataType?.Value;
 
             if (cellValue != null && dataTypeValue == CellValues.SharedString)
             {
-                cellTextValue = cell.Doc.WorkbookPart.SharedStringTablePart.SharedStringTable.ChildElements.GetItem(int.Parse(cellValue)).InnerText;
+                // cellTextValue = sharedStringTable.ChildElements.GetItem(int.Parse(cellValue)).InnerText;
+                cellTextValue = sharedStringTable
+                    .GetWeakCache<string, string>()
+                    .GetOrAdd(cellValue, static (cellValue, sharedStringTable) => sharedStringTable.ChildElements.GetItem(int.Parse(cellValue)).InnerText, sharedStringTable);
             }
 
             if (cellTextValue == null && cellValue != null)
             {
-                propertyParser ??= cell.GetMetadata<IPropertyParser>();
-
-                if (propertyParser != null)
-                    cellTextValue = TryParseAsDateType(cellValue, propertyParser.TargetType);
+                if (targetType != null)
+                {
+                    cellTextValue = TryParseAsDateType(cellValue, targetType);
+                }
             }
 
             return cellTextValue ?? cellValue;
@@ -578,11 +526,13 @@ public static partial class ExcelParsingExtensions
                     // Use first row as headers
                     headers = row.GetHeaders();
 
+                    var propertyParsers = parserProvider.GetParsers().ToArray();
+
                     // Associate parser for each header
                     foreach (var header in headers)
                     {
                         // TODO: RIGID SEARCH. Use predicate?
-                        var propertyParser = parserProvider.GetParsers().FirstOrDefault(parser => parser.SourceName == header.Data.Name);
+                        var propertyParser = propertyParsers.FirstOrDefault(parser => parser.SourceName == header.Data.Name);
                         if (propertyParser != null)
                         {
                             header.SetMetadata(propertyParser);
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/ExcelReportBuilder.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/ExcelReportBuilder.cs
index f4b2760..b6048fe 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/ExcelReportBuilder.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/ExcelReportBuilder.cs
@@ -1,6 +1,7 @@
 // Copyright (c) MicroElements. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -8,6 +9,8 @@
 using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Spreadsheet;
 using MicroElements.CodeContracts;
+using MicroElements.Collections.Extensions.Iterate;
+using MicroElements.Metadata.Experimental;
 using MicroElements.Metadata.OpenXml.Excel.Parsing;
 using NodaTime;
 using Border = DocumentFormat.OpenXml.Spreadsheet.Border;
@@ -357,8 +360,7 @@ private void AddSheetData(
                     CellContext[] cellContexts = new CellContext[columns.Count];
                     for (var i = 0; i < columns.Count; i++)
                     {
-                        var columnContext = columns[i];
-                        cellContexts[i] = ConstructCell(columnContext, dataRow, callCustomize: false);
+                        cellContexts[i] = ConstructCell(columns[i], dataRow, callCustomize: false);
                     }
 
                     // Create row
@@ -370,14 +372,7 @@ private void AddSheetData(
                     // Customize cells
                     for (var i = 0; i < columns.Count; i++)
                     {
-                        CellContext cellContext = cellContexts[i];
-                        var configureCell = ExcelCellMetadata.ConfigureCell.GetFirstDefinedValue(
-                            cellContext.CellMetadata,
-                            cellContext.ColumnContext.ColumnMetadata,
-                            sheetContext.SheetMetadata,
-                            sheetContext.DocumentContext.DocumentMetadata);
-
-                        configureCell?.Invoke(cellContext);
+                        ConfigureCell(ref cellContexts[i]);
                     }
 
                     sheetData.AppendChild(excelRow);
@@ -397,8 +392,8 @@ private void AddSheetData(
                     {
                         var column = columns[index];
                         Row row = excelRows[index];
-                        Cell cell = ConstructCell(column, dataRow).Cell;
-                        row.AppendChild(cell);
+                        CellContext cellContext = ConstructCell(column, dataRow, callCustomize: true);
+                        row.AppendChild(cellContext.Cell);
                     }
                 }
 
@@ -409,6 +404,21 @@ private void AddSheetData(
             }
         }
 
+        private static void ConfigureCell(ref CellContext cellContext)
+        {
+            // var configureCell = ExcelCellMetadata.ConfigureCell.GetFirstDefinedValue(
+            //     cellContext.CellMetadata,
+            //     cellContext.ColumnContext.ColumnMetadata,
+            //     sheetContext.SheetMetadata,
+            //     sheetContext.DocumentContext.DocumentMetadata);
+            // configureCell?.Invoke(cellContext);
+
+            // var customizeFunc = cellMetadata?.GetValue(ExcelCellMetadata.ConfigureCell);
+            // customizeFunc?.Invoke(cellContext);
+
+            cellContext.CellMetadata?.ConfigureCell.ConfigureChain(ref cellContext);
+        }
+
         private Columns CreateColumns(IReadOnlyList<ColumnContext> columns)
         {
             Columns columnsElement = new Columns();
@@ -470,14 +480,15 @@ private Cell ConstructHeaderCell(ColumnContext columnContext)
         {
             Cell headerCell = CreateCell(columnContext.PropertyRenderer.TargetName, CellValues.String);
 
-            var propertyRenderer = columnContext.PropertyRenderer;
+            IPropertyRenderer propertyRenderer = columnContext.PropertyRenderer;
             ExcelColumnMetadata? excelColumnMetadata = propertyRenderer.GetMetadata<ExcelColumnMetadata>();
 
             // External customization
             var customizeFunc = excelColumnMetadata?.GetValue(ExcelColumnMetadata.ConfigureHeaderCell);
             if (customizeFunc != null)
             {
-                customizeFunc.Invoke(new CellContext(columnContext, excelColumnMetadata!, headerCell));
+                // var cellMetadata = propertyRenderer.GetMetadata<ExcelCellMetadata>();
+                customizeFunc.Invoke(new CellContext(columnContext, null, headerCell));
             }
 
             return headerCell;
@@ -489,9 +500,12 @@ private CellContext ConstructCell(ColumnContext columnContext, IPropertyContaine
 
             // Render value
             string? textValue = propertyRenderer.Render(source);
+
+            // Use StringProvider for potential string reusing
             textValue = textValue != null ? _settings.StringProvider.GetString(textValue) : null;
 
-            var cellMetadata = propertyRenderer.GetMetadata<ExcelCellMetadata>();
+            // Get Cell metadata
+            var cellMetadata = propertyRenderer.GetMetadataCached<ExcelCellMetadata>();
 
             CellValues dataType = ExcelMetadata.DataType.GetFirstDefinedValue(
                 cellMetadata,
@@ -517,8 +531,7 @@ private CellContext ConstructCell(ColumnContext columnContext, IPropertyContaine
             // External customization
             if (callCustomize)
             {
-                var customizeFunc = cellMetadata?.GetValue(ExcelCellMetadata.ConfigureCell);
-                customizeFunc?.Invoke(cellContext);
+                ConfigureCell(ref cellContext);
             }
 
             // TODO: omit empty cells? or omit style if cell is empty
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/CellContext.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/CellContext.cs
index 29fe99d..40b81f0 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/CellContext.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/CellContext.cs
@@ -1,6 +1,7 @@
 // Copyright (c) MicroElements. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Collections.Concurrent;
 using DocumentFormat.OpenXml.Spreadsheet;
 using MicroElements.CodeContracts;
 using MicroElements.Metadata.OpenXml.Excel.Parsing;
@@ -20,7 +21,7 @@ public readonly struct CellContext
         /// <summary>
         /// Gets cell metadata.
         /// </summary>
-        public IExcelMetadata? CellMetadata { get; }
+        public ExcelCellMetadata? CellMetadata { get; }
 
         /// <summary>
         /// Gets OpenXml cell.
@@ -43,7 +44,7 @@ public readonly struct CellContext
         /// <param name="columnContext">ColumnContext for this cell.</param>
         /// <param name="cellMetadata">Cell metadata.</param>
         /// <param name="cell">OpenXml cell.</param>
-        public CellContext(ColumnContext columnContext, IExcelMetadata? cellMetadata, Cell cell)
+        public CellContext(ColumnContext columnContext, ExcelCellMetadata? cellMetadata, Cell cell)
         {
             columnContext.AssertArgumentNotNull(nameof(columnContext));
 
@@ -58,7 +59,7 @@ public CellContext(ColumnContext columnContext, IExcelMetadata? cellMetadata, Ce
         /// <returns>Text value.</returns>
         public string? GetCellValue()
         {
-            ExcelElement<Cell> excelCell = new ExcelElement<Cell>(ColumnContext.SheetContext.DocumentContext.Document, Cell);
+            var excelCell = new ExcelElementLight<Cell>(ColumnContext.SheetContext.DocumentContext.Document, Cell);
             string? cellValue = excelCell.GetCellValue();
             return cellValue;
         }
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ConfigureAction.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ConfigureAction.cs
new file mode 100644
index 0000000..fdd5dbd
--- /dev/null
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ConfigureAction.cs
@@ -0,0 +1,51 @@
+using System;
+using MicroElements.CodeContracts;
+using MicroElements.Metadata.Experimental;
+using MicroElements.Metadata.OpenXml.Excel.Styling;
+
+namespace MicroElements.Metadata.OpenXml.Excel.Reporting
+{
+    public delegate void RefAction<T>(ref T value);
+
+    public sealed record ConfigureAction<T>
+    {
+        public RefAction<T>? RefAction { get; }
+
+        public string? Description { get; }
+
+        public ConfigureAction(RefAction<T> configure, string? description = null)
+        {
+            RefAction = configure.AssertArgumentNotNull(nameof(configure));
+            Description = description;
+        }
+    }
+
+    public static class ConfigureExtensions
+    {
+        public static ImmutableChain<T> CombineWith<T>(this ImmutableChain<T>? chain, T value, CombineMode combineMode = CombineMode.AppendToEnd)
+        {
+            switch (combineMode)
+            {
+                case CombineMode.AppendToEnd:
+                    return chain.Append(value);
+                case CombineMode.AppendToStart:
+                    return chain.Prepend(value);
+                case CombineMode.Set:
+                    return ImmutableChain.Create(value);
+            }
+
+            throw new InvalidOperationException();
+        }
+
+        public static void ConfigureChain<T>(this ImmutableChain<ConfigureAction<T>>? configureChain, ref T value)
+        {
+            if (configureChain?.Values is { } configureActions)
+            {
+                foreach (var configure in configureActions)
+                {
+                    configure.RefAction?.Invoke(ref value);
+                }
+            }
+        }
+    }
+}
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ExcelMetadataExtensions.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ExcelMetadataExtensions.cs
index a1efaf1..40cb83a 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ExcelMetadataExtensions.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/ExcelMetadataExtensions.cs
@@ -30,7 +30,15 @@ public static TContainer WithCombinedConfigure<TContainer, TContext>(
         {
             Action<TContext>? existedAction = metadata.GetPropertyValue(property)?.Value;
 
-            return metadata.WithValue(property, context => Combine(context, existedAction, action, combineMode));
+            return metadata.WithValue(property, GetCombinedAction(existedAction, action, combineMode));
+
+            static Action<TContext> GetCombinedAction(Action<TContext>? existedAction, Action<TContext> action, CombineMode combineMode)
+            {
+                if (existedAction is null && combineMode is CombineMode.AppendToStart or CombineMode.AppendToEnd)
+                    return action;
+
+                return context => Combine(context, existedAction, action, combineMode);
+            }
 
             static void Combine(TContext context, Action<TContext>? action1, Action<TContext> action2, CombineMode combineMode)
             {
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/IExcelMetadata.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/IExcelMetadata.cs
index fbb53b6..00f8c2a 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/IExcelMetadata.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/Model/IExcelMetadata.cs
@@ -3,6 +3,7 @@
 
 using System;
 using DocumentFormat.OpenXml.Spreadsheet;
+using MicroElements.Metadata.Experimental;
 using MicroElements.Metadata.Schema;
 
 namespace MicroElements.Metadata.OpenXml.Excel.Reporting
@@ -172,7 +173,7 @@ public class ExcelColumnMetadata : MutablePropertyContainer, IExcelMetadata
         public static readonly IProperty<int> ColumnWidth = ExcelMetadata.ColumnWidth;
 
         /// <summary>
-        /// Sheet customization function.
+        /// Column customization function.
         /// </summary>
         public static readonly IProperty<Action<ColumnContext>> ConfigureColumn = new Property<Action<ColumnContext>>("ConfigureColumn");
 
@@ -182,10 +183,18 @@ public class ExcelColumnMetadata : MutablePropertyContainer, IExcelMetadata
         public static readonly IProperty<Action<CellContext>> ConfigureHeaderCell = new Property<Action<CellContext>>("ConfigureHeaderCell");
     }
 
+    public interface IConfigureCell
+    {
+        /// <summary>
+        /// Gets or sets cell customization chain.
+        /// </summary>
+        ImmutableChain<ConfigureAction<CellContext>>? ConfigureCell { get; set; }
+    }
+
     /// <summary>
     /// Excel Cell customizations.
     /// </summary>
-    public class ExcelCellMetadata : MutablePropertyContainer, IExcelMetadata
+    public class ExcelCellMetadata : MutablePropertyContainer, IExcelMetadata, IConfigureCell
     {
         /// <summary>
         /// Excel data type.
@@ -193,8 +202,8 @@ public class ExcelCellMetadata : MutablePropertyContainer, IExcelMetadata
         public static readonly IProperty<CellValues> DataType = ExcelMetadata.DataType;
 
         /// <summary>
-        /// Cell customization function.
+        /// Gets or sets cell customization chain.
         /// </summary>
-        public static readonly IProperty<Action<CellContext>> ConfigureCell = new Property<Action<CellContext>>("ConfigureCell");
+        public ImmutableChain<ConfigureAction<CellContext>>? ConfigureCell { get; set; }
     }
 }
diff --git a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/StylingExtensions.cs b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/StylingExtensions.cs
index ad65848..e15fdca 100644
--- a/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/StylingExtensions.cs
+++ b/src/MicroElements.Metadata.OpenXml/OpenXml/Excel/Reporting/StylingExtensions.cs
@@ -7,7 +7,9 @@
 using DocumentFormat.OpenXml;
 using DocumentFormat.OpenXml.Spreadsheet;
 using MicroElements.CodeContracts;
+using MicroElements.Metadata.Experimental;
 using MicroElements.Metadata.OpenXml.Excel.Styling;
+using MicroElements.Reflection.FriendlyName;
 
 namespace MicroElements.Metadata.OpenXml.Excel.Reporting
 {
@@ -47,12 +49,36 @@ public static TPropertyRenderer SetExcelType<TPropertyRenderer>(this TPropertyRe
         /// <returns>The same renderer instance.</returns>
         public static TPropertyRenderer ConfigureCell<TPropertyRenderer>(
             this TPropertyRenderer propertyRenderer,
-            Action<CellContext> configureCell,
+            RefAction<CellContext> configureCell,
             CombineMode combineMode = CombineMode.AppendToEnd)
             where TPropertyRenderer : IPropertyRenderer
         {
-            return propertyRenderer.ConfigureMetadata<TPropertyRenderer, ExcelCellMetadata>(
-                metadata => metadata.WithCombinedConfigure(ExcelCellMetadata.ConfigureCell, configureCell, combineMode));
+            return propertyRenderer
+                .ConfigureMetadata<TPropertyRenderer, ExcelCellMetadata>(metadata =>
+                {
+                    metadata.ConfigureCell = metadata.ConfigureCell.CombineWith(new ConfigureAction<CellContext>(configureCell), combineMode);
+                });
+        }
+
+        /// <summary>
+        /// Configures cell.
+        /// </summary>
+        /// <typeparam name="TPropertyRenderer">Property renderer type.</typeparam>
+        /// <param name="propertyRenderer">Property renderer.</param>
+        /// <param name="configureCell">Cell customization action.</param>
+        /// <param name="combineMode">Combine mode. Default: AppendToEnd.</param>
+        /// <returns>The same renderer instance.</returns>
+        public static TPropertyRenderer ConfigureCell<TPropertyRenderer>(
+            this TPropertyRenderer propertyRenderer,
+            ConfigureAction<CellContext> configureCell,
+            CombineMode combineMode = CombineMode.AppendToEnd)
+            where TPropertyRenderer : IPropertyRenderer
+        {
+            return propertyRenderer
+                .ConfigureMetadata<TPropertyRenderer, ExcelCellMetadata>(metadata =>
+                {
+                    metadata.ConfigureCell = metadata.ConfigureCell.CombineWith(configureCell, combineMode);
+                });
         }
 
         /// <summary>
@@ -115,31 +141,29 @@ public static TMetadataProvider ConfigureRow<TMetadataProvider>(
         /// <typeparam name="TPropertyRenderer">Property renderer type.</typeparam>
         /// <param name="propertyRenderer">Property renderer.</param>
         /// <param name="getCellStyle">Function. Input: CellValue, Result: StyleName.</param>
-        /// <param name="mergeMode">StyleApply mode. Default: Merge.</param>
+        /// <param name="configureMode">Configure combine mode. Default: AppendToEnd.</param>
+        /// <param name="styleApplyMode">StyleApply mode. Default: Merge.</param>
         /// <returns>The same renderer instance.</returns>
         public static TPropertyRenderer ConfigureCellStyle<TPropertyRenderer>(
             this TPropertyRenderer propertyRenderer,
             Func<string?, string?> getCellStyle,
-            MergeMode mergeMode = MergeMode.Merge)
+            CombineMode configureMode = CombineMode.AppendToEnd,
+            MergeMode styleApplyMode = MergeMode.Merge)
             where TPropertyRenderer : IPropertyRenderer
         {
             propertyRenderer.AssertArgumentNotNull(nameof(propertyRenderer));
             getCellStyle.AssertArgumentNotNull(nameof(getCellStyle));
 
-            if (mergeMode == MergeMode.Set)
-            {
-                propertyRenderer.ConfigureMetadata<ExcelCellMetadata>(
-                    metadata => metadata.SetValue(ExcelCellMetadata.ConfigureCell, context => ConfigureCellStyleInternal(context, getCellStyle, mergeMode)));
-            }
-            else
+            propertyRenderer.ConfigureMetadata<ExcelCellMetadata>(metadata =>
             {
-                propertyRenderer.ConfigureMetadata<ExcelCellMetadata>(metadata =>
-                    metadata.WithCombinedConfigure(ExcelCellMetadata.ConfigureCell, context => ConfigureCellStyleInternal(context, getCellStyle, mergeMode)));
-            }
+                metadata.ConfigureCell = metadata.ConfigureCell.CombineWith(
+                    new ConfigureAction<CellContext>((ref CellContext context) => ConfigureCellStyleInternal(context, getCellStyle, styleApplyMode), description: "Dynamic style"),
+                    configureMode);
+            });
 
             return propertyRenderer;
 
-            static void ConfigureCellStyleInternal(CellContext context, Func<string?, string?> getCellStyle, MergeMode styleApply)
+            static void ConfigureCellStyleInternal(in CellContext context, Func<string?, string?> getCellStyle, MergeMode styleApply)
             {
                 string? cellValue = context.GetCellValue();
                 string? cellStyle = getCellStyle(cellValue);
@@ -149,6 +173,35 @@ static void ConfigureCellStyleInternal(CellContext context, Func<string?, string
             }
         }
 
+        /// <summary>
+        /// Configures cell style.
+        /// </summary>
+        /// <typeparam name="TPropertyRenderer">Property renderer type.</typeparam>
+        /// <param name="propertyRenderer">Property renderer.</param>
+        /// <param name="cellStyle">StyleName.</param>
+        /// <param name="configureMode">Configure combine mode. Default: AppendToEnd.</param>
+        /// <param name="styleApplyMode">StyleApply mode. Default: Merge.</param>
+        /// <returns>The same renderer instance.</returns>
+        public static TPropertyRenderer ConfigureCellStyle<TPropertyRenderer>(
+            this TPropertyRenderer propertyRenderer,
+            string cellStyle,
+            CombineMode configureMode = CombineMode.AppendToEnd,
+            MergeMode styleApplyMode = MergeMode.Merge)
+            where TPropertyRenderer : IPropertyRenderer
+        {
+            propertyRenderer.AssertArgumentNotNull(nameof(propertyRenderer));
+            cellStyle.AssertArgumentNotNull(nameof(cellStyle));
+
+            propertyRenderer.ConfigureMetadata<ExcelCellMetadata>(metadata =>
+            {
+                metadata.ConfigureCell = metadata.ConfigureCell.CombineWith(
+                    new ConfigureAction<CellContext>((ref CellContext context) => context.ApplyStyleToCell(cellStyle, styleApplyMode), description: $"Style: {cellStyle}"),
+                    configureMode);
+            });
+
+            return propertyRenderer;
+        }
+
         /// <summary>
         /// Applies styling from <see cref="ICellFormatProvider"/>.
         /// </summary>
@@ -163,7 +216,9 @@ public static TPropertyRenderer ApplyStyle<TPropertyRenderer>(
             bool autoRegister = true)
             where TPropertyRenderer : IPropertyRenderer
         {
-            return propertyRenderer.ConfigureCell(context =>
+            return propertyRenderer.ConfigureCell(new ConfigureAction<CellContext>(ApplyStyleInternal, $"CellFormatProvider: {formatProvider.GetType().GetFriendlyName()}"));
+
+            void ApplyStyleInternal(ref CellContext context)
             {
                 var formatName = formatProvider.Name;
 
@@ -178,7 +233,7 @@ public static TPropertyRenderer ApplyStyle<TPropertyRenderer>(
                 }
 
                 context.ApplyStyleToCell(formatName);
-            });
+            }
         }
 
         /// <summary>
@@ -195,7 +250,9 @@ public static TPropertyRenderer ApplyStyle<TPropertyRenderer>(
             bool autoRegister = true)
             where TPropertyRenderer : IPropertyRenderer
         {
-            return propertyRenderer.ConfigureCell(context =>
+            return propertyRenderer.ConfigureCell(new ConfigureAction<CellContext>(ApplyStyleInternal, $"NumberingFormatProvider: {formatProvider.GetType().GetFriendlyName()}"));
+
+            void ApplyStyleInternal(ref CellContext context)
             {
                 var numberingFormatName = formatProvider.Name;
                 var cellFormatName = $"CellFormat.{numberingFormatName}";
@@ -223,7 +280,7 @@ public static TPropertyRenderer ApplyStyle<TPropertyRenderer>(
                 }
 
                 context.ApplyStyleToCell(cellFormatName);
-            });
+            }
         }
 
         /// <summary>
@@ -243,7 +300,7 @@ public static TPropertyRenderer SetExcelSerialDateFormat<TPropertyRenderer>(this
                     object? valueUntyped = container.GetValueUntyped(property, container.SearchOptions.UseDefaultValue(false).ReturnNull());
                     return valueUntyped.ToExcelSerialDateAsString();
                 })
-                .ConfigureCell(context => context.ApplyStyleToCell(registeredStyleName));
+                .ConfigureCell(new ConfigureAction<CellContext>((ref CellContext context) => context.ApplyStyleToCell(registeredStyleName), $"Style: {registeredStyleName}"));
 
             return propertyRenderer;
         }
@@ -380,7 +437,7 @@ public static TExcelMetadata WithExcelDocumentStyles<TExcelMetadata>(this TExcel
         /// <param name="context">Cell context.</param>
         /// <param name="applyStyleName">Style name to apply.</param>
         /// <param name="mergeMode">Apply style.</param>
-        public static void ApplyStyleToCell(this CellContext context, string applyStyleName, MergeMode mergeMode = MergeMode.Merge)
+        public static void ApplyStyleToCell(this in CellContext context, string applyStyleName, MergeMode mergeMode = MergeMode.Merge)
         {
             var documentContext = context.ColumnContext.SheetContext.DocumentContext;
 
diff --git a/src/MicroElements.Metadata/Metadata/ComponentModel/IValueObject.cs b/src/MicroElements.Metadata/Metadata/ComponentModel/IValueObject.cs
new file mode 100644
index 0000000..c386ed0
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/ComponentModel/IValueObject.cs
@@ -0,0 +1,85 @@
+using System;
+
+namespace MicroElements.Metadata.ComponentModel
+{
+    public interface IValueObject
+    {
+        object? Value { get; }
+    }
+
+    public interface IValueObject<out TBaseValue> : IValueObject
+    {
+        /// <inheritdoc />
+        object? IValueObject.Value => Value;
+
+        TBaseValue? Value { get; }
+    }
+
+    /// <summary>
+    /// Generic builder interface.
+    /// </summary>
+    public interface IValueObjectBuilder
+    {
+    }
+
+    /// <summary>
+    /// Generic builder that knows how to build with the provided component type.
+    /// It's supposed to be used with immutable objects.
+    /// For mutable objects use <see cref="ICompositeSetter{TComponent}"/>.
+    /// </summary>
+    /// <typeparam name="TBaseValue">Component type.</typeparam>
+    public interface IValueObjectBuilder<in TBaseValue> : IValueObjectBuilder
+    {
+        /// <summary>
+        /// Creates a copy of the source with provided <paramref name="component"/>.
+        /// </summary>
+        /// <param name="component">The component.</param>
+        /// <returns>The source copy or the source itself in case of mutable object.</returns>
+        object Create(TBaseValue component);
+    }
+
+    public interface IValueObjectBuilder<out TValueObject, TBaseValue> :
+        IValueObjectBuilder<TBaseValue>,
+        IValueObject<TBaseValue>
+    {
+        /// <inheritdoc />
+        object IValueObjectBuilder<TBaseValue>.Create(TBaseValue component) => Create(component);
+
+        /// <summary>
+        /// Creates a copy of the source with provided <paramref name="component"/>.
+        /// </summary>
+        /// <param name="value">The component.</param>
+        /// <returns>The source copy or the source itself in case of mutable object.</returns>
+        TValueObject Create(TBaseValue value);
+
+        TValueObject CreateAuto(TBaseValue value)
+        {
+            return (TValueObject)Activator.CreateInstance(typeof(TValueObject), value);
+        }
+
+        //static abstract TValueObject CreateStatic(TComponent component);
+    }
+
+    // public static class aaaa
+    // {
+    //     public static T Create<T>()
+    //     {
+    //
+    //     }
+    // }
+
+    public readonly record struct Cur(string Value) : IValueObjectBuilder<Cur, string>
+    {
+        /// <inheritdoc />
+        public Cur Create(string value) => new Cur(value);
+    }
+
+    public static class aaa
+    {
+        public static T As<T>(this string value)
+            where T : struct, IValueObjectBuilder<T, string>
+        {
+            return default(T).Create(value);
+        }
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/Experimental/ImmutableChain.cs b/src/MicroElements.Metadata/Metadata/Experimental/ImmutableChain.cs
new file mode 100644
index 0000000..5a46d62
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/Experimental/ImmutableChain.cs
@@ -0,0 +1,135 @@
+// Copyright (c) MicroElements. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using MicroElements.Text.StringFormatter;
+
+#pragma warning disable CS1591
+#pragma warning disable SA1401: Fields should be private
+#pragma warning disable SA1611: Element parameters should be documented
+#pragma warning disable SA1615: Element return value should be documented
+#pragma warning disable SA1618: Generic type parameters should be documented
+#pragma warning disable SA1600: Elements should be documented
+
+namespace MicroElements.Metadata.Experimental
+{
+    /// <summary>
+    /// Immutable object chain.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the chain.</typeparam>
+    public class ImmutableChain<T> : IReadOnlyList<T>
+    {
+        public static readonly ImmutableChain<T> Empty = new(value: default, left: null, right: null, isValue: false);
+
+        internal readonly T? Value;
+        internal readonly ImmutableChain<T>? Left;
+        internal readonly ImmutableChain<T>? Right;
+
+        // Allows to cache values in a list for cheap iterations.
+        private readonly Lazy<IReadOnlyList<T>> _lazyValues;
+
+        internal ImmutableChain(T? value = default, ImmutableChain<T>? left = null, ImmutableChain<T>? right = null, bool isValue = true)
+        {
+            if (isValue && left == null && right == null)
+                (Value, Left, Right) = (value, this, null);
+            else
+                (Value, Left, Right) = (value, left, right);
+
+            _lazyValues = new(this.ToArray);
+        }
+
+        /// <summary>
+        /// Gets cached values as list. Enumeration is expensive in hot paths.
+        /// </summary>
+        public IReadOnlyList<T> Values => _lazyValues.Value;
+
+        /// <inheritdoc />
+        public IEnumerator<T> GetEnumerator()
+        {
+            if (Left != null)
+            {
+                if (Left == this)
+                {
+                    yield return Value!;
+                }
+                else
+                {
+                    foreach (var value in Left)
+                    {
+                        yield return value;
+                    }
+                }
+            }
+
+            if (Right != null)
+            {
+                foreach (var value in Right)
+                {
+                    yield return value;
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <inheritdoc />
+        public int Count => Values.Count;
+
+        /// <inheritdoc />
+        public T this[int index] => Values[index];
+
+        /// <inheritdoc />
+        public override string ToString() => this.FormatAsTuple();
+    }
+
+    /// <summary>
+    /// ImmutableChain extensions.
+    /// </summary>
+    public static class ImmutableChain
+    {
+        /// <summary> Gets value indicating that chain is null or empty. </summary>
+        public static bool IsNullOrEmpty<T>([NotNullWhen(false)] this ImmutableChain<T>? chain)
+            => chain is null || (chain.Left == null && chain.Right == null);
+
+        /// <summary> Creates chain with provided elements. Can create empty collection. </summary>
+        public static ImmutableChain<T> Create<T>(params T[]? values) =>
+            values == null || values.Length == 0
+                ? ImmutableChain<T>.Empty
+                : values.Aggregate(ImmutableChain<T>.Empty, (current, value) => current.Append(value));
+
+        /// <summary>
+        /// Appends <paramref name="value"/> to the end of collection.
+        /// </summary>
+        /// <param name="chain">Prev collection instance.</param>
+        /// <param name="value">Value to append.</param>
+        /// <typeparam name="T">Value type.</typeparam>
+        /// <returns>New collection instance.</returns>
+        public static ImmutableChain<T> Append<T>(this ImmutableChain<T>? chain, T value)
+            => chain.Append(new ImmutableChain<T>(value));
+
+        /// <summary>
+        /// Appends other chain to the source.
+        /// </summary>
+        /// <param name="chain">The source collection.</param>
+        /// <param name="other">Values to append.</param>
+        /// <typeparam name="T">Value type.</typeparam>
+        /// <returns>New collection instance.</returns>
+        public static ImmutableChain<T> Append<T>(this ImmutableChain<T>? chain, ImmutableChain<T> other)
+            => chain.IsNullOrEmpty() ? other : new ImmutableChain<T>(left: chain, right: other);
+
+        /// <summary>
+        /// Prepends collection with provided value.
+        /// </summary>
+        /// <param name="chain">Prev collection instance.</param>
+        /// <param name="value">Value to prepend.</param>
+        /// <typeparam name="T">Value type.</typeparam>
+        /// <returns>New collection instance.</returns>
+        public static ImmutableChain<T> Prepend<T>(this ImmutableChain<T>? chain, T value)
+            => chain.IsNullOrEmpty() ? new ImmutableChain<T>(value) : new ImmutableChain<T>(value).Append(chain);
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/IPropertyValue.cs b/src/MicroElements.Metadata/Metadata/IPropertyValue.cs
index 23157e7..90b72ca 100644
--- a/src/MicroElements.Metadata/Metadata/IPropertyValue.cs
+++ b/src/MicroElements.Metadata/Metadata/IPropertyValue.cs
@@ -42,6 +42,12 @@ public interface IPropertyValue<out T> : IPropertyValue
         /// Gets property value.
         /// </summary>
         T? Value { get; }
+
+        /// <inheritdoc />
+        IProperty IPropertyValue.PropertyUntyped => Property;
+
+        /// <inheritdoc />
+        object? IPropertyValue.ValueUntyped => Source == ValueSource.NotDefined ? null : Value;
     }
 
     /// <summary>
diff --git a/src/MicroElements.Metadata/Metadata/Indexed.cs b/src/MicroElements.Metadata/Metadata/Indexed.cs
new file mode 100644
index 0000000..99909ac
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/Indexed.cs
@@ -0,0 +1,211 @@
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MicroElements.Metadata;
+
+public interface IIndexedPropertyContainer
+{
+    IPropertyValue? GetPropertyValue(IProperty property);
+
+    int GetPropertyIndex(IProperty property);
+    //IPropertyValue? GetPropertyValue(int index);
+}
+
+public class PropertyIndex
+{
+    private Dictionary<IProperty, int> _propertyIndex;
+
+    public IReadOnlyList<IProperty> Properties { get; }
+
+    public IEqualityComparer<IProperty> PropertyComparer { get; }
+
+    public IPropertyValueFactory PropertyValueFactory { get; }
+
+
+    public PropertyIndex(IPropertySet propertySet, IEqualityComparer<IProperty> propertyComparer)
+    {
+        if (propertySet.GetProperties() is IReadOnlyList<IProperty> properties)
+        {
+            Properties = properties;
+        }
+        else
+        {
+            Properties = propertySet.GetProperties().ToArray();
+        }
+
+        PropertyComparer = propertyComparer;
+
+        _propertyIndex = new Dictionary<IProperty, int>(PropertyComparer);
+    }
+
+    public int GetPropertyIndex(IProperty property)
+    {
+        return _propertyIndex.GetValueOrDefault(property, -1);
+    }
+}
+
+public class IndexedPropertyContainer2 : IPropertyContainer, IIndexedPropertyContainer
+{
+    private readonly PropertyIndex _propertyIndex;
+
+    private readonly object[] _values;
+    private readonly ValueSource[] _valueSource;
+
+    public IndexedPropertyContainer2(PropertyIndex propertyIndex)
+    {
+        _propertyIndex = propertyIndex;
+
+        int propertiesCount = _propertyIndex.Properties.Count;
+        _values = new object[propertiesCount];
+        _valueSource = new ValueSource[propertiesCount];
+    }
+
+    /// <inheritdoc />
+    public IPropertyValue? GetPropertyValue(IProperty property)
+    {
+        int propertyIndex = _propertyIndex.GetPropertyIndex(property);
+
+        if (propertyIndex >= 0)
+        {
+            return PropertyValue.Create(_propertyIndex.Properties[propertyIndex], _values[propertyIndex], _valueSource[propertyIndex]);
+        }
+
+        return null;
+    }
+
+    /// <inheritdoc />
+    public int GetPropertyIndex(IProperty property)
+    {
+        throw new System.NotImplementedException();
+    }
+
+    /// <inheritdoc />
+    public IEnumerator<IPropertyValue> GetEnumerator()
+    {
+        for (var i = 0; i < _propertyIndex.Properties.Count; i++)
+        {
+            yield return PropertyValue.Create(_propertyIndex.Properties[i], _values[i], _valueSource[i]);
+        }
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyCollection<IPropertyValue> Properties => this.ToArray();
+
+    /// <inheritdoc />
+    public int Count => _values.Length;
+
+    /// <inheritdoc />
+    public IPropertyContainer? ParentSource { get; }
+
+    /// <inheritdoc />
+    public SearchOptions SearchOptions { get; }
+
+    /// <inheritdoc />
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
+
+public sealed class IndexedPropertyContainer : IPropertyContainer, IIndexedPropertyContainer
+{
+    public static SearchOptions DefaultSearchOptions = SearchOptions.ExistingOnly.WithPropertyComparer(ByTypeAndNamePropertyComparer.Strict);
+    private readonly IPropertyContainer _propertyContainer;
+    private readonly Dictionary<IProperty, IPropertyValue> _propertyValuesDictionary;
+    private readonly SearchOptions _searchOptions;
+
+    public IndexedPropertyContainer(IPropertyContainer propertyContainer, SearchOptions? searchOptions = null)
+    {
+        _propertyContainer = propertyContainer;
+        _searchOptions = searchOptions ?? propertyContainer.SearchOptions;
+        _propertyValuesDictionary = MakeIndex(propertyContainer);
+    }
+
+    private Dictionary<IProperty, IPropertyValue> MakeIndex(IPropertyContainer propertyContainer)
+    {
+        var propertyValues = new Dictionary<IProperty, IPropertyValue>(_searchOptions.PropertyComparer);
+
+        foreach (IPropertyValue propertyValue in propertyContainer)
+        {
+            propertyValues[propertyValue.PropertyUntyped] = propertyValue;
+        }
+
+        return propertyValues;
+    }
+
+    public IPropertyValue? GetPropertyValue(IProperty property)
+    {
+        return _propertyValuesDictionary.GetValueOrDefault(property);
+    }
+
+    /// <inheritdoc />
+    public int GetPropertyIndex(IProperty property)
+    {
+        throw new System.NotImplementedException();
+    }
+
+    public SearchOptions SearchOptions => _searchOptions;
+
+    public IPropertyContainer? ParentSource => _propertyContainer.ParentSource;
+
+    public IReadOnlyCollection<IPropertyValue> Properties => _propertyContainer.Properties;
+
+    public int Count => _propertyContainer.Count;
+
+    public IPropertyContainer GetMetadataContainer(bool autoCreate = false)
+        => _propertyContainer.GetMetadataContainer(autoCreate);
+
+    public void SetMetadataContainer(IPropertyContainer metadata)
+        => _propertyContainer.SetMetadataContainer(metadata);
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public IEnumerator<IPropertyValue> GetEnumerator() => _propertyContainer.GetEnumerator();
+}
+
+public sealed class IndexedSearch : ISearchAlgorithm
+{
+    private ISearchAlgorithm _searchAlgorithm;
+    private ConcurrentDictionary<IEqualityComparer<IProperty>, ConcurrentDictionary<IProperty, int>> _index = new ();
+
+    public IndexedSearch(ISearchAlgorithm searchAlgorithm)
+    {
+        _searchAlgorithm = searchAlgorithm;
+    }
+
+    public IPropertyValue? SearchPropertyValueUntyped(IPropertyContainer propertyContainer, IProperty property, SearchOptions? searchOptions = null)
+    {
+        if (propertyContainer is IIndexedPropertyContainer indexed)
+        {
+            return indexed.GetPropertyValue(property);
+        }
+
+        return _searchAlgorithm.SearchPropertyValueUntyped(propertyContainer, property, searchOptions);
+    }
+
+    public IPropertyValue<T>? GetPropertyValue<T>(IPropertyContainer propertyContainer, IProperty<T> property, SearchOptions? searchOptions = null)
+    {
+        if (propertyContainer is IIndexedPropertyContainer indexed)
+        {
+            return (IPropertyValue<T>)indexed.GetPropertyValue(property);
+        }
+
+        return _searchAlgorithm.GetPropertyValue(propertyContainer, property, searchOptions);
+    }
+
+    /// <inheritdoc />
+    public void GetPropertyValue2<T>(IPropertyContainer propertyContainer, IProperty<T> property, SearchOptions? searchOptions,
+        out PropertyValueData<T> result)
+    {
+        throw new System.NotImplementedException();
+    }
+}
+
+public static class IndexedExtensions
+{
+    public static IPropertyContainer? Indexed(this IPropertyContainer? propertyContainer, SearchOptions? searchOptions)
+    {
+        if (propertyContainer == null)
+            return null;
+        return new IndexedPropertyContainer(propertyContainer, searchOptions ?? IndexedPropertyContainer.DefaultSearchOptions);
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/MetadataProvider.Cached.cs b/src/MicroElements.Metadata/Metadata/MetadataProvider.Cached.cs
new file mode 100644
index 0000000..002df12
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/MetadataProvider.Cached.cs
@@ -0,0 +1,22 @@
+using MicroElements.Collections.TwoLayerCache;
+
+namespace MicroElements.Metadata;
+
+public static partial class MetadataProviderExtensions
+{
+    /// <summary>
+    /// Cached version of <see cref="GetMetadata{TMetadata}"/>.
+    /// </summary>
+    /// <inheritdoc cref="GetMetadata{TMetadata}"/>
+    public static TMetadata? GetMetadataCached<TMetadata>(
+        this IMetadataProvider metadataProvider,
+        string? metadataName = null,
+        TMetadata? defaultValue = default,
+        bool searchInSchema = false)
+    {
+        return TwoLayerCache
+            .Instance<(IMetadataProvider MetadataProvider, string? MetadataName, bool SearchInSchema), TMetadata?>()
+            .GetOrAdd((metadataProvider, metadataName, searchInSchema), (key, def) =>
+                    key.MetadataProvider.GetMetadata<TMetadata>(key.MetadataName, searchInSchema: key.SearchInSchema, defaultValue: def), defaultValue);
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/MetadataProviderExtensions.cs b/src/MicroElements.Metadata/Metadata/MetadataProviderExtensions.cs
index b3ec322..6a8043f 100644
--- a/src/MicroElements.Metadata/Metadata/MetadataProviderExtensions.cs
+++ b/src/MicroElements.Metadata/Metadata/MetadataProviderExtensions.cs
@@ -11,7 +11,7 @@ namespace MicroElements.Metadata
     /// <summary>
     /// Provides extension methods for metadata providers.
     /// </summary>
-    public static class MetadataProviderExtensions
+    public static partial class MetadataProviderExtensions
     {
         /// <summary>
         /// Returns a value indicating whether the metadata provider has any metadata.
diff --git a/src/MicroElements.Metadata/Metadata/Parsing/IParseResult.cs b/src/MicroElements.Metadata/Metadata/Parsing/IParseResult.cs
index ec2310d..1644b64 100644
--- a/src/MicroElements.Metadata/Metadata/Parsing/IParseResult.cs
+++ b/src/MicroElements.Metadata/Metadata/Parsing/IParseResult.cs
@@ -47,7 +47,7 @@ public interface IParseResult
     /// Strong typed parse result.
     /// </summary>
     /// <typeparam name="T">Value type.</typeparam>
-    public interface IParseResult<T> : IParseResult
+    public interface IParseResult<out T> : IParseResult
     {
         /// <summary>
         /// Gets result value.
diff --git a/src/MicroElements.Metadata/Metadata/PropertyCalculator.cs b/src/MicroElements.Metadata/Metadata/PropertyCalculator.cs
index 81f2960..7428cc4 100644
--- a/src/MicroElements.Metadata/Metadata/PropertyCalculator.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertyCalculator.cs
@@ -12,6 +12,27 @@ namespace MicroElements.Metadata
     /// <typeparam name="T">Value type.</typeparam>
     public delegate T? CalculateDelegate<out T>(ref CalculationContext context);
 
+    public delegate T? CalculateDelegate<out T, in TState>(ref CalculationContext context, TState state);
+
+    public sealed class PropertyCalculator<T, TState> : IPropertyCalculator<T>
+    {
+        private readonly CalculateDelegate<T, TState>? _calculate;
+        private readonly TState _state;
+
+        public PropertyCalculator(CalculateDelegate<T, TState>? calculate, TState state)
+        {
+            _calculate = calculate;
+            _state = state;
+        }
+
+        /// <inheritdoc />
+        public T? Calculate(ref CalculationContext context)
+        {
+            var calculationResult = _calculate(ref context, _state);
+            return calculationResult;
+        }
+    }
+
     /// <summary>
     /// Property calculator that accepts evaluate func in simple and full form.
     /// </summary>
diff --git a/src/MicroElements.Metadata/Metadata/PropertyContainer.cs b/src/MicroElements.Metadata/Metadata/PropertyContainer.cs
index 1a1aaf0..687503d 100644
--- a/src/MicroElements.Metadata/Metadata/PropertyContainer.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertyContainer.cs
@@ -5,7 +5,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using MicroElements.Metadata.Formatting;
 
@@ -55,22 +54,22 @@ public PropertyContainer(
         }
 
         /// <inheritdoc />
-        public IEnumerator<IPropertyValue> GetEnumerator() => Properties.GetEnumerator();
+        public IReadOnlyCollection<IPropertyValue> Properties { get; }
 
         /// <inheritdoc />
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        public IPropertyContainer? ParentSource { get; }
 
         /// <inheritdoc />
-        public int Count => Properties.Count;
+        public SearchOptions SearchOptions { get; }
 
         /// <inheritdoc />
-        public IPropertyContainer? ParentSource { get; }
+        public int Count => Properties.Count;
 
         /// <inheritdoc />
-        public IReadOnlyCollection<IPropertyValue> Properties { get; }
+        public IEnumerator<IPropertyValue> GetEnumerator() => Properties.GetEnumerator();
 
         /// <inheritdoc />
-        public SearchOptions SearchOptions { get; }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
         /// <inheritdoc />
         public override string ToString()
diff --git a/src/MicroElements.Metadata/Metadata/PropertyExtensions.Map.cs b/src/MicroElements.Metadata/Metadata/PropertyExtensions.Map.cs
new file mode 100644
index 0000000..5f15997
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/PropertyExtensions.Map.cs
@@ -0,0 +1,62 @@
+using System;
+using MicroElements.Metadata.Schema;
+using MicroElements.Reflection.ObjectExtensions;
+
+namespace MicroElements.Metadata;
+
+public static partial class PropertyExtensions
+{
+    public static IProperty<TResult?> MapNew<TSource, TResult>(
+        this IProperty<TSource> property,
+        Func<TSource?, TResult?> map,
+        bool allowMapNull = false,
+        bool allowMapUndefined = false,
+        Func<SearchOptions, SearchOptions>? configureSearch = null)
+    {
+        var state = new MapState<TSource, TResult>(property, map, allowMapNull, allowMapUndefined, configureSearch);
+        var propertyCalculator = new PropertyCalculator<TResult?, MapState<TSource, TResult>>(
+            calculate: static (ref CalculationContext context, MapState<TSource, TResult> mapState)
+                => MapInternal(ref context, mapState), state);
+
+        return new Property<TResult?>(property.Name)
+            .With(description: property.Description, alias: property.Alias)
+            .WithPropertyCalculator(propertyCalculator);
+    }
+
+    private sealed record MapState<TSource, TResult>(
+        IProperty<TSource> property,
+        Func<TSource?, TResult?> map,
+        bool allowMapNull = false,
+        bool allowMapUndefined = false,
+        Func<SearchOptions, SearchOptions>? configureSearch = null);
+
+    private static TResult? MapInternal<TSource, TResult>(ref CalculationContext context, MapState<TSource, TResult> state)
+    {
+        var search = state.configureSearch?.Invoke(context.SearchOptions) ?? context.SearchOptions;
+        //IPropertyValue<TSource>? sourcePropertyValue = context.PropertyContainer.GetPropertyValue(state.property, search);
+        DefaultSearchAlgorithm.Instance.GetPropertyValue2(context.PropertyContainer, state.property, search, out var sourcePropertyValue);
+
+        if (sourcePropertyValue.Source != ValueSource.NotDefined)
+        {
+            TSource? sourceValue = sourcePropertyValue.Value;
+            if (!sourceValue.IsNull() || state.allowMapNull)
+            {
+                TResult? resultValue1 = state.map(sourceValue);
+                context.ValueSource = ValueSource.Calculated;
+                return resultValue1;
+            }
+        }
+        else
+        {
+            if (state.allowMapUndefined)
+            {
+                TResult? resultValue2 = state.map(default);
+                context.ValueSource = ValueSource.Calculated;
+                return resultValue2;
+            }
+        }
+
+        context.ValueSource = ValueSource.NotDefined;
+        return default;
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/PropertyExtensions.cs b/src/MicroElements.Metadata/Metadata/PropertyExtensions.cs
index 279cdd4..83307ba 100644
--- a/src/MicroElements.Metadata/Metadata/PropertyExtensions.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertyExtensions.cs
@@ -11,7 +11,7 @@ namespace MicroElements.Metadata
     /// <summary>
     /// Property extensions.
     /// </summary>
-    public static class PropertyExtensions
+    public static partial class PropertyExtensions
     {
         /// <summary>
         /// Gets property name and possible aliases.
@@ -100,7 +100,7 @@ public static IEnumerable<string> GetNameAndAliases(this IProperty property)
 
             return new Property<TResult?>(property.Name)
                 .With(description: property.Description, alias: property.Alias)
-                .WithCalculate(ConvertValue);
+                .WithCalculate((container, options) => ConvertValue(container, options));
         }
 
         /// <summary>
diff --git a/src/MicroElements.Metadata/Metadata/PropertySet.cs b/src/MicroElements.Metadata/Metadata/PropertySet.cs
index 1c59ca9..fbe778d 100644
--- a/src/MicroElements.Metadata/Metadata/PropertySet.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertySet.cs
@@ -10,7 +10,7 @@ namespace MicroElements.Metadata
     /// </summary>
     public sealed class PropertySet : IPropertySet
     {
-        private readonly List<IProperty> _properties = new List<IProperty>();
+        private readonly List<IProperty> _properties = new();
 
         /// <summary>
         /// Gets the property list.
@@ -26,7 +26,7 @@ public sealed class PropertySet : IPropertySet
         /// <param name="properties">Property list.</param>
         public PropertySet(params IProperty[]? properties)
         {
-            if (properties != null && properties.Length > 0)
+            if (properties != null)
                 _properties.AddRange(properties);
         }
 
diff --git a/src/MicroElements.Metadata/Metadata/PropertyValue.cs b/src/MicroElements.Metadata/Metadata/PropertyValue.cs
index ed3dae0..891fcdd 100644
--- a/src/MicroElements.Metadata/Metadata/PropertyValue.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertyValue.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Diagnostics.CodeAnalysis;
 using MicroElements.CodeContracts;
 using MicroElements.Metadata.Formatting;
 using MicroElements.Reflection.TypeExtensions;
@@ -21,12 +20,6 @@ public sealed class PropertyValue<T> : IPropertyValue<T>
         /// <inheritdoc />
         public T? Value { get; }
 
-        /// <inheritdoc />
-        public IProperty PropertyUntyped => Property;
-
-        /// <inheritdoc />
-        public object? ValueUntyped => Source == ValueSource.NotDefined ? null : Value;
-
         /// <inheritdoc />
         public ValueSource Source { get; }
 
@@ -47,8 +40,7 @@ public PropertyValue(IProperty<T> property, T? value, ValueSource? source = null
         /// Implicitly converts to <typeparamref name="T"/>.
         /// </summary>
         /// <param name="propertyValue">PropertyValue.</param>
-        [return: MaybeNull]
-        public static implicit operator T(PropertyValue<T> propertyValue) => propertyValue.Value;
+        public static implicit operator T?(PropertyValue<T> propertyValue) => propertyValue.Value;
 
         /// <inheritdoc />
         public override string ToString() => $"{Property.Name}: {Value.FormatValue("null")}";
@@ -57,7 +49,7 @@ public PropertyValue(IProperty<T> property, T? value, ValueSource? source = null
     /// <summary>
     /// Represents value source.
     /// </summary>
-    public sealed class ValueSource
+    public sealed record ValueSource
     {
         /// <summary>
         /// Value is not set.
@@ -93,18 +85,6 @@ public ValueSource(string sourceName)
             SourceName = sourceName.AssertArgumentNotNull(nameof(sourceName));
         }
 
-        private bool Equals(ValueSource other) => SourceName == other.SourceName;
-
-        /// <inheritdoc />
-        public override bool Equals(object? obj) => ReferenceEquals(this, obj) || (obj is ValueSource other && Equals(other));
-
-        /// <inheritdoc />
-        public override int GetHashCode() => SourceName.GetHashCode();
-
-        public static bool operator ==(ValueSource? left, ValueSource? right) => Equals(left, right);
-
-        public static bool operator !=(ValueSource? left, ValueSource? right) => !Equals(left, right);
-
         /// <inheritdoc />
         public override string ToString() => SourceName;
     }
diff --git a/src/MicroElements.Metadata/Metadata/PropertyValueData.cs b/src/MicroElements.Metadata/Metadata/PropertyValueData.cs
new file mode 100644
index 0000000..21d57a9
--- /dev/null
+++ b/src/MicroElements.Metadata/Metadata/PropertyValueData.cs
@@ -0,0 +1,15 @@
+namespace MicroElements.Metadata;
+
+public struct PropertyValueData<T> : IPropertyValue<T>
+{
+    public IProperty<T> Property { get; }
+    public T? Value { get; }
+    public ValueSource Source { get; }
+
+    public PropertyValueData(IProperty<T> property, T? value, ValueSource source)
+    {
+        Property = property;
+        Value = value;
+        Source = source;
+    }
+}
diff --git a/src/MicroElements.Metadata/Metadata/PropertyValueFactory.cs b/src/MicroElements.Metadata/Metadata/PropertyValueFactory.cs
index 1e9533f..4adb31a 100644
--- a/src/MicroElements.Metadata/Metadata/PropertyValueFactory.cs
+++ b/src/MicroElements.Metadata/Metadata/PropertyValueFactory.cs
@@ -116,6 +116,21 @@ public static Expression<Func<IPropertyValueFactory, IProperty, object, ValueSou
         }
     }
 
+    public class EmptyPropertyValueFactory : IPropertyValueFactory
+    {
+        /// <inheritdoc />
+        public IPropertyValue<T> Create<T>(IProperty<T> property, T? value, ValueSource? valueSource = null)
+        {
+            return null;
+        }
+
+        /// <inheritdoc />
+        public IPropertyValue CreateUntyped(IProperty property, object? value, ValueSource? valueSource = null)
+        {
+            return null;
+        }
+    }
+
     /// <summary>
     /// Cached <see cref="IPropertyValue"/> factory.
     /// </summary>
diff --git a/src/MicroElements.Metadata/Metadata/Schema/INameAlias.cs b/src/MicroElements.Metadata/Metadata/Schema/INameAlias.cs
index 3c7c7e3..c6180d3 100644
--- a/src/MicroElements.Metadata/Metadata/Schema/INameAlias.cs
+++ b/src/MicroElements.Metadata/Metadata/Schema/INameAlias.cs
@@ -78,6 +78,19 @@ public static TSchema WithNameAlias<TSchema>(this TSchema source, INameAlias nam
             return source.WithSchemaComponent(nameAlias);
         }
 
+        /// <summary>
+        /// Creates schema copy with provided name alias.
+        /// </summary>
+        /// <typeparam name="TSchema">Schema type.</typeparam>
+        /// <param name="source">Source schema.</param>
+        /// <param name="nameAlias">Description.</param>
+        /// <returns>New schema instance with provided name alias.</returns>
+        public static TSchema WithNameAlias<TSchema>(this TSchema source, string nameAlias)
+            where TSchema : ISchemaBuilder<INameAlias>, ISchema
+        {
+            return source.WithSchemaComponent(new NameAlias(nameAlias));
+        }
+
         /// <summary>
         /// Gets Alias from <see cref="INameAlias"/>.
         /// </summary>
diff --git a/src/MicroElements.Metadata/Metadata/Searching/ByTypeAndNamePropertyComparer.cs b/src/MicroElements.Metadata/Metadata/Searching/ByTypeAndNamePropertyComparer.cs
index 3a9ec8a..04c1c6c 100644
--- a/src/MicroElements.Metadata/Metadata/Searching/ByTypeAndNamePropertyComparer.cs
+++ b/src/MicroElements.Metadata/Metadata/Searching/ByTypeAndNamePropertyComparer.cs
@@ -12,19 +12,21 @@ namespace MicroElements.Metadata
     /// </summary>
     public sealed partial class ByTypeAndNamePropertyComparer : IEqualityComparer<IProperty>
     {
-        private readonly StringComparison _typeNameComparison;
+        private readonly StringComparison _nameComparison;
+        private readonly StringComparer _nameComparer;
         private readonly bool _ignoreTypeNullability;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ByTypeAndNamePropertyComparer"/> class.
         /// </summary>
-        /// <param name="typeNameComparison">StringComparison for property name comparing.</param>
+        /// <param name="nameComparison">StringComparison for property name comparing.</param>
         /// <param name="ignoreTypeNullability">Compare types ignore Nullable wrapper type.</param>
         public ByTypeAndNamePropertyComparer(
-            StringComparison typeNameComparison = StringComparison.Ordinal,
+            StringComparison nameComparison = StringComparison.Ordinal,
             bool ignoreTypeNullability = false)
         {
-            _typeNameComparison = typeNameComparison;
+            _nameComparison = nameComparison;
+            _nameComparer = StringComparer.FromComparison(nameComparison);
             _ignoreTypeNullability = ignoreTypeNullability;
         }
 
@@ -37,10 +39,18 @@ public bool Equals(IProperty? x, IProperty? y)
             if (ReferenceEquals(x, y))
                 return true;
 
-            Type typeX = _ignoreTypeNullability && x.Type.GetTypeInfo().IsValueType ? Nullable.GetUnderlyingType(x.Type) ?? x.Type : x.Type;
-            Type typeY = _ignoreTypeNullability && y.Type.GetTypeInfo().IsValueType ? Nullable.GetUnderlyingType(y.Type) ?? y.Type : y.Type;
+            Type typeX = x.Type;
+            Type typeY = y.Type;
 
-            return typeX == typeY && x.Name.Equals(y.Name, _typeNameComparison);
+            if (_ignoreTypeNullability)
+            {
+                if (typeX.GetTypeInfo().IsValueType && Nullable.GetUnderlyingType(typeX) is { } underlyingTypeX)
+                    typeX = underlyingTypeX;
+                if (typeY.GetTypeInfo().IsValueType && Nullable.GetUnderlyingType(typeY) is { } underlyingTypeY)
+                    typeY = underlyingTypeY;
+            }
+
+            return typeX == typeY && x.Name.Equals(y.Name, _nameComparison);
         }
 
         /// <inheritdoc/>
@@ -49,10 +59,8 @@ public int GetHashCode(IProperty property)
             string propertyName = property.Name;
             Type propertyType = property.Type;
 
-            if (_typeNameComparison == StringComparison.OrdinalIgnoreCase ||
-                _typeNameComparison == StringComparison.InvariantCultureIgnoreCase ||
-                _typeNameComparison == StringComparison.CurrentCultureIgnoreCase)
-                propertyName = propertyName.ToLower();
+            HashCode hashCode = default;
+            hashCode.Add(propertyName, _nameComparer);
 
             if (_ignoreTypeNullability
                 && propertyType.GetTypeInfo().IsValueType
@@ -61,7 +69,9 @@ public int GetHashCode(IProperty property)
                 propertyType = underlyingType;
             }
 
-            return HashCode.Combine(propertyName, propertyType);
+            hashCode.Add(propertyType);
+
+            return hashCode.ToHashCode();
         }
     }
 
@@ -73,16 +83,16 @@ public sealed partial class ByTypeAndNamePropertyComparer
         /// <summary>
         /// Gets property comparer by Type and Name.
         /// </summary>
-        public static IEqualityComparer<IProperty> Strict { get; } = new ByTypeAndNamePropertyComparer(typeNameComparison: StringComparison.Ordinal, ignoreTypeNullability: false);
+        public static IEqualityComparer<IProperty> Strict { get; } = new ByTypeAndNamePropertyComparer(nameComparison: StringComparison.Ordinal, ignoreTypeNullability: false);
 
         /// <summary>
         /// Gets property comparer by Type and Name ignore case.
         /// </summary>
-        public static IEqualityComparer<IProperty> IgnoreNameCase { get; } = new ByTypeAndNamePropertyComparer(typeNameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: false);
+        public static IEqualityComparer<IProperty> IgnoreNameCase { get; } = new ByTypeAndNamePropertyComparer(nameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: false);
 
         /// <summary>
         /// Gets property comparer by Type and Name ignoring name case and ignoring <see cref="Nullable{T}"/> wrapper.
         /// </summary>
-        public static IEqualityComparer<IProperty> IgnoreNameCaseIgnoreNullability { get; } = new ByTypeAndNamePropertyComparer(typeNameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: true);
+        public static IEqualityComparer<IProperty> IgnoreNameCaseIgnoreNullability { get; } = new ByTypeAndNamePropertyComparer(nameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: true);
     }
 }
diff --git a/src/MicroElements.Metadata/Metadata/Searching/DefaultSearchAlgorithm.cs b/src/MicroElements.Metadata/Metadata/Searching/DefaultSearchAlgorithm.cs
index f871d4f..522ce05 100644
--- a/src/MicroElements.Metadata/Metadata/Searching/DefaultSearchAlgorithm.cs
+++ b/src/MicroElements.Metadata/Metadata/Searching/DefaultSearchAlgorithm.cs
@@ -17,6 +17,8 @@ public sealed class DefaultSearchAlgorithm : ISearchAlgorithm
         /// </summary>
         public static readonly ISearchAlgorithm Instance = new DefaultSearchAlgorithm();
 
+        // TODO: Вынести IPropertyValueFactory в SearchOptions?
+        // TODO: IPropertyValue возвращать из Calculator?
         private readonly IPropertyValueFactory _propertyValueFactory = PropertyValueFactory.Default;
         private IPropertyValueFactoryProvider _factoryProvider = new PropertyValueFactoryProvider(comparer => PropertyValueFactory.Default);
 
@@ -35,27 +37,35 @@ public sealed class DefaultSearchAlgorithm : ISearchAlgorithm
 
             // Search property by EqualityComparer
             IPropertyValue? propertyValue = null;
-            var properties = propertyContainer.Properties;
-            if (properties is IList<IPropertyValue> propertyValues)
+
+            if (propertyContainer is IIndexedPropertyContainer indexed)
+            {
+                propertyValue = indexed.GetPropertyValue(property);
+            }
+            else
             {
-                // For is for performance reason here
-                for (int i = 0; i < propertyValues.Count; i++)
+                var properties = propertyContainer.Properties;
+                if (properties is IList<IPropertyValue> propertyValues)
                 {
-                    if (search.PropertyComparer.Equals(propertyValues[i].PropertyUntyped, property))
+                    // For is for performance reason here
+                    for (int i = 0; i < propertyValues.Count; i++)
                     {
-                        propertyValue = propertyValues[i];
-                        break;
+                        if (search.PropertyComparer.Equals(propertyValues[i].PropertyUntyped, property))
+                        {
+                            propertyValue = propertyValues[i];
+                            break;
+                        }
                     }
                 }
-            }
-            else
-            {
-                foreach (IPropertyValue? pv in propertyContainer.Properties)
+                else
                 {
-                    if (search.PropertyComparer.Equals(pv.PropertyUntyped, property))
+                    foreach (IPropertyValue? pv in propertyContainer.Properties)
                     {
-                        propertyValue = pv;
-                        break;
+                        if (search.PropertyComparer.Equals(pv.PropertyUntyped, property))
+                        {
+                            propertyValue = pv;
+                            break;
+                        }
                     }
                 }
             }
@@ -107,7 +117,7 @@ public sealed class DefaultSearchAlgorithm : ISearchAlgorithm
                 var calculationContext = new CalculationContext(propertyContainer, search);
                 var calculatedValue = calculator.Calculate(ref calculationContext);
                 var calculatedValueSource = calculationContext.ValueSource ?? ValueSource.NotDefined;
-                var calculatedPropertyValue = _propertyValueFactory.Create(property, calculatedValue, calculatedValueSource);
+                IPropertyValue<T>? calculatedPropertyValue = _propertyValueFactory.Create(property, calculatedValue, calculatedValueSource);
 
                 if (calculatedPropertyValue.Source == ValueSource.NotDefined && !search.ReturnNotDefined)
                     calculatedPropertyValue = null;
@@ -131,5 +141,58 @@ public sealed class DefaultSearchAlgorithm : ISearchAlgorithm
             // Return null or NotDefined
             return search.ReturnNotDefined ? _propertyValueFactory.Create(property, default, ValueSource.NotDefined) : null;
         }
+
+        /// <inheritdoc />
+        public void GetPropertyValue2<T>(
+            IPropertyContainer propertyContainer,
+            IProperty<T> property,
+            SearchOptions? searchOptions,
+            out PropertyValueData<T> result)
+        {
+            SearchOptions search = searchOptions ?? propertyContainer.SearchOptions;
+
+            // Base search by ByReferenceComparer.
+            IPropertyValue<T>? propertyValue = SearchPropertyValueUntyped(propertyContainer, property, _fastSearchOptions) as IPropertyValue<T>;
+
+            // Good job - return result!
+            if (propertyValue != null)
+            {
+                result = new PropertyValueData<T>(property, propertyValue.Value, propertyValue.Source);
+                return;
+            }
+
+            // Property can be calculated.
+            if (search.CalculateValue && property.GetCalculator() is { } calculator)
+            {
+                var calculationContext = new CalculationContext(propertyContainer, search);
+                var calculatedValue = calculator.Calculate(ref calculationContext);
+                var calculatedValueSource = calculationContext.ValueSource ?? ValueSource.NotDefined;
+
+                result = new PropertyValueData<T>(property, calculatedValue, calculatedValueSource);
+                return;
+            }
+
+            // Search by provided options.
+            propertyValue = SearchPropertyValueUntyped(propertyContainer, property, search
+                .UseDefaultValue(false)
+                .ReturnNull()) as IPropertyValue<T>;
+
+            // Nice. We have result!
+            if (propertyValue != null)
+            {
+                result = new PropertyValueData<T>(property, propertyValue.Value, propertyValue.Source);
+                return;
+            }
+
+            // Maybe default value?
+            if (search.UseDefaultValue && property.DefaultValue is { } defaultValue)
+            {
+                result = new PropertyValueData<T>(property, defaultValue.Value, ValueSource.DefaultValue);
+                return;
+            }
+
+            // Return null or NotDefined
+            result = new PropertyValueData<T>(property, default, ValueSource.NotDefined);
+        }
     }
 }
diff --git a/src/MicroElements.Metadata/Metadata/Searching/ISearchAlgorithm.cs b/src/MicroElements.Metadata/Metadata/Searching/ISearchAlgorithm.cs
index d818df4..2d6a3b9 100644
--- a/src/MicroElements.Metadata/Metadata/Searching/ISearchAlgorithm.cs
+++ b/src/MicroElements.Metadata/Metadata/Searching/ISearchAlgorithm.cs
@@ -32,5 +32,11 @@ public interface ISearchAlgorithm
             IPropertyContainer propertyContainer,
             IProperty<T> property,
             SearchOptions? searchOptions = null);
+
+        void GetPropertyValue2<T>(
+            IPropertyContainer propertyContainer,
+            IProperty<T> property,
+            SearchOptions? searchOptions,
+            out PropertyValueData<T> result);
     }
 }
diff --git a/src/MicroElements.Metadata/Metadata/Searching/PropertyComparer.cs b/src/MicroElements.Metadata/Metadata/Searching/PropertyComparer.cs
index 4e08e40..c788ad7 100644
--- a/src/MicroElements.Metadata/Metadata/Searching/PropertyComparer.cs
+++ b/src/MicroElements.Metadata/Metadata/Searching/PropertyComparer.cs
@@ -38,12 +38,12 @@ public static class PropertyComparer
         /// <summary>
         /// Property comparer by Type and Name ignore case.
         /// </summary>
-        public static IEqualityComparer<IProperty> ByTypeAndNameIgnoreCaseComparer { get; } = new ByTypeAndNamePropertyComparer(typeNameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: false);
+        public static IEqualityComparer<IProperty> ByTypeAndNameIgnoreCaseComparer { get; } = new ByTypeAndNamePropertyComparer(nameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: false);
 
         /// <summary>
         /// Property comparer by Type and Name ignoring name case and ignoring <see cref="Nullable{T}"/> wrapper.
         /// </summary>
-        public static IEqualityComparer<IProperty> ByTypeAndNameIgnoreCaseIgnoreNullability { get; } = new ByTypeAndNamePropertyComparer(typeNameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: true);
+        public static IEqualityComparer<IProperty> ByTypeAndNameIgnoreCaseIgnoreNullability { get; } = new ByTypeAndNamePropertyComparer(nameComparison: StringComparison.OrdinalIgnoreCase, ignoreTypeNullability: true);
 
         /// <summary>
         /// Property comparer by <see cref="ISchema.Name"/> or <see cref="INameAlias.Alias"/> ignore case.
diff --git a/src/MicroElements.Metadata/Metadata/Searching/SearchExtensions.cs b/src/MicroElements.Metadata/Metadata/Searching/SearchExtensions.cs
index b3f8e5c..f5b90d7 100644
--- a/src/MicroElements.Metadata/Metadata/Searching/SearchExtensions.cs
+++ b/src/MicroElements.Metadata/Metadata/Searching/SearchExtensions.cs
@@ -157,7 +157,7 @@ public static partial class SearchExtensions
         /// <param name="propertyContainer">Property container.</param>
         /// <param name="search">Search conditions.</param>
         /// <returns><see cref="IPropertyValue"/> or null.</returns>
-        public static IPropertyValue<T>? GetPropertyValue<T>(this IPropertyContainer propertyContainer, [DisallowNull] SearchOptions search)
+        public static IPropertyValue<T>? GetPropertyValue<T>(this IPropertyContainer propertyContainer, SearchOptions search)
         {
             if (search.SearchProperty == null)
                 throw new InvalidOperationException("SearchProperty must be set in SearchOptions.");
@@ -174,7 +174,7 @@ public static partial class SearchExtensions
         /// <param name="propertyContainer">Property container.</param>
         /// <param name="search">Search conditions.</param>
         /// <returns><see cref="IPropertyValue"/> or null.</returns>
-        public static IPropertyValue? SearchPropertyValueUntyped(this IPropertyContainer propertyContainer, [DisallowNull] SearchOptions search)
+        public static IPropertyValue? SearchPropertyValueUntyped(this IPropertyContainer propertyContainer, SearchOptions search)
         {
             if (search.SearchProperty == null)
                 throw new InvalidOperationException("SearchProperty must be set in SearchOptions.");
diff --git a/src/MicroElements.Metadata/MicroElements.Metadata.csproj b/src/MicroElements.Metadata/MicroElements.Metadata.csproj
index 4115b7d..466c3af 100644
--- a/src/MicroElements.Metadata/MicroElements.Metadata.csproj
+++ b/src/MicroElements.Metadata/MicroElements.Metadata.csproj
@@ -5,13 +5,13 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
     <RootNamespace>MicroElements</RootNamespace>
-    <LangVersion>9.0</LangVersion>
+    <LangVersion>10</LangVersion>
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="MicroElements.CodeContracts.Sources" Version="1.3.0" PrivateAssets="all" />
-    <PackageReference Include="MicroElements.Collections.Sources" Version="1.6.0" PrivateAssets="all" />
+    <PackageReference Include="MicroElements.Collections.Sources" Version="1.7.0" PrivateAssets="all" />
     <PackageReference Include="MicroElements.Formatting.Sources" Version="1.0.0" PrivateAssets="all" />
     <PackageReference Include="MicroElements.Reflection.Sources" Version="1.8.0" PrivateAssets="all" />
   </ItemGroup>
diff --git a/src/MicroElements.Metadata/Validation/ValidationResult.cs b/src/MicroElements.Metadata/Validation/ValidationResult.cs
index ed20dc5..d7f8bc1 100644
--- a/src/MicroElements.Metadata/Validation/ValidationResult.cs
+++ b/src/MicroElements.Metadata/Validation/ValidationResult.cs
@@ -36,6 +36,17 @@ public ValidationResult(T data, IReadOnlyCollection<Message>? validationMessages
             ValidationMessages = validationMessages ?? Array.Empty<Message>();
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ValidationResult{T}"/> struct.
+        /// </summary>
+        /// <param name="data">Data that was validated.</param>
+        /// <param name="validationMessages">Validation messages.</param>
+        public ValidationResult(T data, params Message[]? validationMessages)
+        {
+            Data = data.AssertArgumentNotNull(nameof(data));
+            ValidationMessages = validationMessages ?? Array.Empty<Message>();
+        }
+
         /// <summary>
         /// Validation result can be implicitly cast to its Data type.
         /// </summary>
diff --git a/test/MicroElements.Metadata.Benchmarks/MapBench.cs b/test/MicroElements.Metadata.Benchmarks/MapBench.cs
new file mode 100644
index 0000000..afad214
--- /dev/null
+++ b/test/MicroElements.Metadata.Benchmarks/MapBench.cs
@@ -0,0 +1,41 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Order;
+
+namespace MicroElements.Metadata.Benchmarks
+{
+    [MemoryDiagnoser]
+    [Config(typeof(CustomConfig))]
+    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+    public class MapBench
+    {
+        public static Property<string> Prop1 = new Property<string>("Prop1");
+        public static Property<string> Name = new Property<string>("Name");
+        public static IPropertyContainer Container = new MutablePropertyContainer()
+            .WithValue(Prop1, "Prop1")
+            .WithValue(Name, "Alex");
+
+        IProperty<string> mappedName1 = Name.Map(name => name);
+        IProperty<string> mappedName2 = Name.MapNew(name => name);
+
+        IProperty<string> mappedName3 = Name.Map(value => "");
+
+        [Benchmark]
+        public string NoMap()
+        {
+            return Container.GetValue(Name);
+        }
+
+        [Benchmark]
+        public string Map()
+        {
+            return Container.GetValue(mappedName1);
+        }
+
+        [Benchmark(Baseline = true)]
+        public string MapNew()
+        {
+            DefaultSearchAlgorithm.Instance.GetPropertyValue2(Container, mappedName2, null, out var result);
+            return result.Value;
+        }
+    }
+}
diff --git a/test/MicroElements.Metadata.Benchmarks/Program.cs b/test/MicroElements.Metadata.Benchmarks/Program.cs
index c0313d7..ad56bc6 100644
--- a/test/MicroElements.Metadata.Benchmarks/Program.cs
+++ b/test/MicroElements.Metadata.Benchmarks/Program.cs
@@ -8,7 +8,7 @@ public class Program
     {
         public static void Main(string[] args)
         {
-            var summary = BenchmarkRunner.Run<BuilderBench>();
+            var summary = BenchmarkRunner.Run<MapBench>();
         }
     }
 
diff --git a/test/MicroElements.Metadata.Benchmarks/StructInRef.cs b/test/MicroElements.Metadata.Benchmarks/StructInRef.cs
new file mode 100644
index 0000000..2f9fdc9
--- /dev/null
+++ b/test/MicroElements.Metadata.Benchmarks/StructInRef.cs
@@ -0,0 +1,63 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Order;
+
+namespace MicroElements.Metadata.Benchmarks
+{
+    [MemoryDiagnoser]
+    [Config(typeof(CustomConfig))]
+    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+    public class ConfigureStructOrStructRef
+    {
+        public class MutableData
+        {
+            public string Text { get; set; }
+            public double Number { get; set; }
+        }
+
+        public readonly struct ExcelMeta
+        {
+            public MutableData Data1 { get; }
+            public MutableData Data2 { get; }
+            public MutableData Data3 { get; }
+            public MutableData Data4 { get; }
+            public MutableData Data5 { get; }
+
+            public ExcelMeta(MutableData data1, MutableData data2, MutableData data3, MutableData data4, MutableData data5)
+            {
+                Data1 = data1;
+                Data2 = data2;
+                Data3 = data3;
+                Data4 = data4;
+                Data5 = data5;
+            }
+        }
+
+        public delegate void RefAction<T>(ref T value);
+
+        public static Action<ExcelMeta> Configure = (meta => meta.Data1.Text = "text");
+        public static RefAction<ExcelMeta> ConfigureRef = (ref ExcelMeta meta) => meta.Data1.Text = "text";
+
+        public static MutableData Data1 = new MutableData();
+        public static MutableData Data2 = new MutableData();
+        public static MutableData Data3 = new MutableData();
+        public static MutableData Data4 = new MutableData();
+        public static MutableData Data5 = new MutableData();
+
+        [Benchmark(Baseline = true)]
+        public string ConfigureStruct()
+        {
+            ExcelMeta excelMeta = new ExcelMeta(Data1, Data2, Data3, Data4, Data5);
+            Configure(excelMeta);
+            return excelMeta.Data1.Text;
+        }
+
+        [Benchmark]
+        public string ConfigureStructRef()
+        {
+            ExcelMeta excelMeta = new ExcelMeta(Data1, Data2, Data3, Data4, Data5);
+            ConfigureRef(ref excelMeta);
+            return excelMeta.Data1.Text;
+        }
+    }
+}
diff --git a/test/MicroElements.Metadata.Tests/MetadataTests.cs b/test/MicroElements.Metadata.Tests/MetadataTests.cs
index 95ca00b..3e6746b 100644
--- a/test/MicroElements.Metadata.Tests/MetadataTests.cs
+++ b/test/MicroElements.Metadata.Tests/MetadataTests.cs
@@ -91,8 +91,8 @@ public void DynamicContainer()
         [Fact]
         public void PropertySetTests()
         {
-            PropertySet propertySet = new PropertySet(new[] {new Property<string>("prop1"), new Property<string>("prop2"),});
-            propertySet.Properties.Count().Should().Be(2);
+            PropertySet propertySet = new(new Property<string>("prop1"), new Property<string>("prop2"));
+            propertySet.Properties.Count.Should().Be(2);
             propertySet.Properties.Last().Name.Should().Be("prop2");
         }
 
diff --git a/test/MicroElements.Metadata.Tests/PropertyMapTests.cs b/test/MicroElements.Metadata.Tests/PropertyMapTests.cs
index 7c1bcd6..2ffd7e0 100644
--- a/test/MicroElements.Metadata.Tests/PropertyMapTests.cs
+++ b/test/MicroElements.Metadata.Tests/PropertyMapTests.cs
@@ -26,6 +26,10 @@ public void calculate_value_if_base_property_value_provided()
                 .WithValue(Name, "Alex");
 
             container.GetValue(Name.Map(name => $"Calculated {name}")).Should().Be("Calculated Alex");
+            container.GetValue(Name.MapNew(name => $"Calculated {name}")).Should().Be("Calculated Alex");
+
+            DefaultSearchAlgorithm.Instance.GetPropertyValue2(container, Name.MapNew(name => $"Calculated {name}"), null, out var result);
+            result.Value.Should().Be("Calculated Alex");
         }
 
         [Fact]
@@ -136,7 +140,7 @@ public void TestComplexProperty()
             IProperty<double?> nullableDouble = new Property<double?>("nullableDouble");
             IProperty<double> deNullify = nullableDouble.DeNullify();
             var property = deNullify.UseDefaultForUndefined();
-            
+
             var propertyContainer = new PropertyContainer();
 
             var propertyValue = propertyContainer.GetPropertyValue(property);
diff --git a/test/MicroElements.Metadata.Tests/PropertyTests.cs b/test/MicroElements.Metadata.Tests/PropertyTests.cs
index b2dc400..4e79dd0 100644
--- a/test/MicroElements.Metadata.Tests/PropertyTests.cs
+++ b/test/MicroElements.Metadata.Tests/PropertyTests.cs
@@ -4,6 +4,7 @@
 using FluentAssertions;
 using MicroElements.Diagnostics;
 using MicroElements.Metadata.ComponentModel;
+using MicroElements.Metadata.Experimental;
 using MicroElements.Metadata.Schema;
 using MicroElements.Metadata.Xml;
 using Xunit;
@@ -12,6 +13,27 @@ namespace MicroElements.Metadata.Tests
 {
     public class PropertyTests
     {
+        [Fact]
+        public static void ImmutableChainTest()
+        {
+            ImmutableChain<int>? chain_null = null;
+            ImmutableChain<int> chain_null_1 = chain_null.Append(1);
+            chain_null_1.Values.Should().Equal(1);
+
+            ImmutableChain<int> chain_1 = ImmutableChain.Create(1);
+            chain_1.Values.Should().Equal(1);
+            ImmutableChain<int> chain_1_2 = chain_1.Append(2);
+            ImmutableChain<int> chain_1_2_3 = chain_1_2.Append(3);
+            ImmutableChain<int> chain_1_2_3_4 = chain_1_2_3.Append(4);
+            chain_1_2_3_4.Values.Should().Equal(1, 2, 3, 4);
+
+            ImmutableChain<int> chain_1_2_1_2 = chain_1_2.Append(chain_1_2);
+            chain_1_2_1_2.Values.Should().Equal(1, 2, 1, 2);
+
+            ImmutableChain<int> chain_3_1_2 = chain_1_2.Prepend(3);
+            chain_3_1_2.Values.Should().Equal(3, 1, 2);
+        }
+
         [Fact]
         public void empty_property_should_be_empty()
         {
@@ -49,7 +71,7 @@ public void property_with_name_should_change_name()
             var test4 = CreateFilledProperty().WithNameUntyped("test4");
             ((IProperty<int>)test4).ShouldBeFilled(name: "test4");
 
-            var test5 = CreateFilledProperty().WithAliasUntyped("alias5");
+            var test5 = CreateFilledProperty().WithNameAlias("alias5");// .WithAliasUntyped("alias5");
             ((IProperty<int>)test5).ShouldBeFilled(alias: "alias5");
         }
 
@@ -167,7 +189,7 @@ public XmlLineInfo(int lineNumber, int linePosition)
 
         [Fact]
         public void message_builder1()
-        { 
+        {
             string? parseResultErrorMessage = "ParseError";
             var message =
                 ValueMessageBuilder
@@ -271,7 +293,7 @@ public void property_calculator()
         {
             Property<string> withCalculate = new Property<string>("Currency")
                 .WithCalculate(container => "EUR");
-            
+
         }
 
         [Fact]
@@ -346,7 +368,7 @@ public static Property<int> CreateFilledProperty()
         }
 
         public static void ShouldBeFilled(
-            this IProperty<int> property, 
+            this IProperty<int> property,
             string? name = "test",
             string? alias = "alias")
         {
diff --git a/test/MicroElements.Metadata.Tests/PropertyValueTests.cs b/test/MicroElements.Metadata.Tests/PropertyValueTests.cs
index 2d4e54d..cc0024f 100644
--- a/test/MicroElements.Metadata.Tests/PropertyValueTests.cs
+++ b/test/MicroElements.Metadata.Tests/PropertyValueTests.cs
@@ -8,9 +8,14 @@ public class PropertyValueTests
         [Fact]
         public void not_defined_property_value_should_return_null()
         {
-            new PropertyValue<int>(new Property<int>("IntDefined"), 1).ValueUntyped.Should().Be(1);
-            new PropertyValue<int>(new Property<int>("IntDefined"), 0).ValueUntyped.Should().Be(0);
-            new PropertyValue<int>(new Property<int>("IntNotDefined"), 0, ValueSource.NotDefined).ValueUntyped.Should().Be(null);
+            IPropertyValue<int> intDefined = new PropertyValue<int>(new Property<int>("IntDefined"), 1);
+            intDefined.ValueUntyped.Should().Be(1);
+
+            IPropertyValue<int> intDefined0 = new PropertyValue<int>(new Property<int>("IntDefined"), 0);
+            intDefined0.ValueUntyped.Should().Be(0);
+
+            IPropertyValue<int> intNotDefined = new PropertyValue<int>(new Property<int>("IntNotDefined"), 0, ValueSource.NotDefined);
+            intNotDefined.ValueUntyped.Should().Be(null);
         }
     }
 }