diff --git a/ClosedXML/ClosedXML/..svnbridge/.svnbridge b/ClosedXML/ClosedXML/..svnbridge/.svnbridge
new file mode 100644
index 0000000..3f623dd
--- /dev/null
+++ b/ClosedXML/ClosedXML/..svnbridge/.svnbridge
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?><ItemProperties xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Properties><Property><Name>svn:ignore</Name><Value>*.suo
+</Value></Property></Properties></ItemProperties>
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/..svnbridge/.svnbridge b/ClosedXML/ClosedXML/ClosedXML/..svnbridge/.svnbridge
new file mode 100644
index 0000000..bdf168c
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/..svnbridge/.svnbridge
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?><ItemProperties xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Properties><Property><Name>svn:ignore</Name><Value>bin
+obj
+</Value></Property></Properties></ItemProperties>
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj b/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
index caa2eea..7bc89fe 100644
--- a/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML/ClosedXML.csproj
@@ -251,11 +251,9 @@
     <Compile Include="Excel\XLWorksheets.cs" />
     <Compile Include="Excel\XLWSContentManager.cs" />
     <Compile Include="Extensions.cs" />
+    <Compile Include="PathHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <WCFMetadata Include="Service References\" />
-  </ItemGroup>
   <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
index df40ba2..00bb80c 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Cells/XLCell.cs
@@ -1086,7 +1086,7 @@
             }
             else
             {
-                var address = new XLAddress(worksheet, a1Address);
+                var address = XLAddress.Create(worksheet, a1Address);
 
                 String rowPart = GetR1C1Row(address.RowNumber, address.FixedRow, rowsToShift);
                 String columnPart = GetR1C1Column(address.ColumnNumber, address.FixedRow, columnsToShift);
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/IXLAddress.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/IXLAddress.cs
index 6c466dc..c2a29c1 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/IXLAddress.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/IXLAddress.cs
@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace ClosedXML.Excel
 {
-    public interface IXLAddress : IEqualityComparer<IXLAddress>, IEquatable<IXLAddress>, IComparable, IComparable<IXLAddress>
+    public interface IXLAddress : IEqualityComparer<IXLAddress>, IEquatable<IXLAddress>
     {
         IXLWorksheet Worksheet { get; }
         Int32 RowNumber { get; }
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeAddress.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeAddress.cs
index 0845dd0..8fccb20 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeAddress.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeAddress.cs
@@ -1,46 +1,21 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
 namespace ClosedXML.Excel
 {
-    internal class XLRangeAddress: IXLRangeAddress
+    internal class XLRangeAddress : IXLRangeAddress
     {
-        public IXLWorksheet Worksheet { get; internal set; }
-
-        private IXLAddress firstAddress;
-        public IXLAddress FirstAddress
-        {
-            get 
-            {
-                if (IsInvalid)
-                    throw new Exception("Range is invalid.");
-
-                return firstAddress; 
-            }
-            set { firstAddress = value; }
-        }
-
-        private IXLAddress lastAddress;
-        public IXLAddress LastAddress
-        {
-            get 
-            {
-                if (IsInvalid)
-                    throw new Exception("Range is an invalid state.");
-
-                return lastAddress; 
-            }
-            set { lastAddress = value; }
-        }
-
-        public Boolean IsInvalid { get; set; }
-
+        #region Private fields
+        private IXLAddress m_firstAddress;
+        private IXLAddress m_lastAddress;
+        #endregion
+        #region Constructor
         public XLRangeAddress(IXLAddress firstAddress, IXLAddress lastAddress)
         {
             if (firstAddress.Worksheet != lastAddress.Worksheet)
+            {
                 throw new ArgumentException("First and last addresses must be in the same worksheet");
+            }
 
             Worksheet = firstAddress.Worksheet;
             FirstAddress = firstAddress;
@@ -51,9 +26,13 @@
         {
             String addressToUse;
             if (rangeAddress.Contains("!"))
+            {
                 addressToUse = rangeAddress.Substring(rangeAddress.IndexOf("!") + 1);
+            }
             else
+            {
                 addressToUse = rangeAddress;
+            }
 
             XLAddress firstAddress;
             XLAddress lastAddress;
@@ -62,48 +41,82 @@
                 String[] arrRange = addressToUse.Split(':');
                 var firstPart = arrRange[0];
                 var secondPart = arrRange[1];
-                firstAddress = new XLAddress(worksheet, firstPart);
-                lastAddress = new XLAddress(worksheet, secondPart);
+                firstAddress = XLAddress.Create(worksheet, firstPart);
+                lastAddress = XLAddress.Create(worksheet, secondPart);
             }
             else
             {
-                firstAddress = new XLAddress(worksheet, addressToUse);
-                lastAddress = new XLAddress(worksheet, addressToUse);
+                firstAddress = XLAddress.Create(worksheet, addressToUse);
+                lastAddress = XLAddress.Create(worksheet, addressToUse);
             }
             FirstAddress = firstAddress;
             LastAddress = lastAddress;
             Worksheet = worksheet;
         }
+        #endregion
+        #region Public properties
+        public IXLWorksheet Worksheet { get; internal set; }
 
+        public IXLAddress FirstAddress
+        {
+            get
+            {
+                if (IsInvalid)
+                {
+                    throw new Exception("Range is invalid.");
+                }
+
+                return m_firstAddress;
+            }
+            set { m_firstAddress = value; }
+        }
+
+        public IXLAddress LastAddress
+        {
+            get
+            {
+                if (IsInvalid)
+                {
+                    throw new Exception("Range is an invalid state.");
+                }
+
+                return m_lastAddress;
+            }
+            set { m_lastAddress = value; }
+        }
+
+        public Boolean IsInvalid { get; set; }
+        #endregion
+        #region Public methods
         public override string ToString()
         {
-            return firstAddress.ToString() + ":" + lastAddress.ToString();
+            return m_firstAddress + ":" + m_lastAddress;
         }
 
         public String ToStringRelative()
         {
-            return firstAddress.ToStringRelative() + ":" + lastAddress.ToStringRelative();
+            return m_firstAddress.ToStringRelative() + ":" + m_lastAddress.ToStringRelative();
         }
         public String ToStringFixed()
         {
-            return firstAddress.ToStringFixed() + ":" + lastAddress.ToStringFixed();
+            return m_firstAddress.ToStringFixed() + ":" + m_lastAddress.ToStringFixed();
         }
 
         public override bool Equals(object obj)
         {
-            var other = (XLRangeAddress)obj;
-            return 
-                    this.Worksheet.Equals(other.Worksheet)
-                && this.FirstAddress.Equals(other.FirstAddress)
-                && this.LastAddress.Equals(other.LastAddress);
+            var other = (XLRangeAddress) obj;
+            return Worksheet.Equals(other.Worksheet)
+                    && FirstAddress.Equals(other.FirstAddress)
+                    && LastAddress.Equals(other.LastAddress);
         }
 
         public override int GetHashCode()
         {
             return
-                Worksheet.GetHashCode()
-                ^ FirstAddress.GetHashCode()
-                ^ LastAddress.GetHashCode();
+                    Worksheet.GetHashCode()
+                    ^ FirstAddress.GetHashCode()
+                    ^ LastAddress.GetHashCode();
         }
+        #endregion
     }
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
index 9f7b4d8..2f0aea8 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/Ranges/XLRangeBase.cs
@@ -8,12 +8,16 @@
 {
     internal abstract class XLRangeBase : IXLRangeBase, IXLStylized
     {
-        public XLRangeBase(IXLRangeAddress rangeAddress)
+        #region Fields
+        protected IXLStyle defaultStyle;
+        #endregion
+        #region Constructor
+        protected XLRangeBase(IXLRangeAddress rangeAddress)
         {
             RangeAddress = rangeAddress;
         }
-
-        protected IXLStyle defaultStyle;
+        #endregion
+        
         public IXLRangeAddress RangeAddress { get; protected set; }
         public IXLWorksheet Worksheet
         {
@@ -81,7 +85,7 @@
         }
         public IXLCell Cell(String cellAddressInRange)
         {
-            return this.Cell(new XLAddress(Worksheet, cellAddressInRange));
+            return this.Cell(XLAddress.Create(Worksheet, cellAddressInRange));
         }
 
         public IXLCell Cell(Int32 row, String column)
@@ -151,7 +155,7 @@
         }
         public IXLRange Range(String firstCellAddress, String lastCellAddress)
         {
-            var rangeAddress = new XLRangeAddress(new XLAddress(Worksheet, firstCellAddress), new XLAddress(Worksheet, lastCellAddress));
+            var rangeAddress = new XLRangeAddress(XLAddress.Create(Worksheet, firstCellAddress), XLAddress.Create(Worksheet, lastCellAddress));
             return Range(rangeAddress);
         }
         public IXLRange Range(Int32 firstCellRow, Int32 firstCellColumn, Int32 lastCellRow, Int32 lastCellColumn)
@@ -169,9 +173,11 @@
             var newFirstCellAddress = (XLAddress)rangeAddress.FirstAddress + (XLAddress)this.RangeAddress.FirstAddress - 1;
             newFirstCellAddress.FixedRow = rangeAddress.FirstAddress.FixedRow;
             newFirstCellAddress.FixedColumn = rangeAddress.FirstAddress.FixedColumn;
+
             var newLastCellAddress = (XLAddress)rangeAddress.LastAddress + (XLAddress)this.RangeAddress.FirstAddress - 1;
             newLastCellAddress.FixedRow = rangeAddress.LastAddress.FixedRow;
             newLastCellAddress.FixedColumn = rangeAddress.LastAddress.FixedColumn;
+
             var newRangeAddress = new XLRangeAddress(newFirstCellAddress, newLastCellAddress);
             var xlRangeParameters = new XLRangeParameters(newRangeAddress, this.Style);
             if (
@@ -603,26 +609,34 @@
             if (addressToUse.Contains(':'))
             {
                 String[] arrRange = addressToUse.Split(':');
-                firstAddress = new XLAddress(Worksheet, arrRange[0]);
-                lastAddress = new XLAddress(Worksheet, arrRange[1]);
+                firstAddress = XLAddress.Create(Worksheet, arrRange[0]);
+                lastAddress = XLAddress.Create(Worksheet, arrRange[1]);
             }
             else
             {
-                firstAddress = new XLAddress(Worksheet, addressToUse);
-                lastAddress = new XLAddress(Worksheet, addressToUse);
+                firstAddress = XLAddress.Create(Worksheet, addressToUse);
+                lastAddress = XLAddress.Create(Worksheet, addressToUse);
             }
-            return
-                firstAddress >= (XLAddress)this.RangeAddress.FirstAddress
-                && lastAddress <= (XLAddress)this.RangeAddress.LastAddress;
+            return Contains(firstAddress, lastAddress);
         }
 
         public Boolean Contains(IXLRangeBase range)
         {
-            return
-                (XLAddress)range.RangeAddress.FirstAddress >= (XLAddress)this.RangeAddress.FirstAddress
-                && (XLAddress)range.RangeAddress.LastAddress <= (XLAddress)this.RangeAddress.LastAddress;
+            return Contains((XLAddress)range.RangeAddress.FirstAddress, (XLAddress)range.RangeAddress.LastAddress);
         }
 
+        public Boolean Contains(XLAddress first, XLAddress last)
+        {
+            return Contains(first) && Contains(last);
+        }
+
+        public Boolean Contains(XLAddress address)
+        {
+            return RangeAddress.FirstAddress.RowNumber <= address.RowNumber && address.RowNumber <= RangeAddress.LastAddress.RowNumber &&
+                   RangeAddress.FirstAddress.ColumnNumber <= address.ColumnNumber && address.ColumnNumber <= RangeAddress.LastAddress.ColumnNumber;
+        }
+
+
         public Boolean Intersects(String rangeAddress)
         {
             return this.Intersects(Range(rangeAddress));
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLAddress.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLAddress.cs
index f5e51c2..9e04d7e 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLAddress.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLAddress.cs
@@ -1,106 +1,75 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
 using System.Globalization;
 
 namespace ClosedXML.Excel
 {
-    internal class XLAddress: IXLAddress
+    internal class XLAddress : IXLAddress
     {
-        #region Constructors
-        /// <summary>
-        /// Initializes a new <see cref="XLAddress"/> struct using R1C1 notation.
-        /// </summary>
-        /// <param name="rowNumber">The row number of the cell address.</param>
-        /// <param name="columnNumber">The column number of the cell address.</param>
-        public XLAddress(IXLWorksheet worksheet, Int32 rowNumber, Int32 columnNumber, Boolean fixedRow, Boolean fixedColumn)
+        #region Static
+        public static XLAddress Create(IXLWorksheet worksheet, string cellAddressString)
         {
-            this.Worksheet = worksheet;
-            this.rowNumber = rowNumber;
-            this.columnNumber = columnNumber;
-            this.columnLetter = null;
-            this.fixedColumn = fixedColumn;
-            this.fixedRow = fixedRow;
-
-            hashCode = rowNumber ^ columnNumber;
-        }
-
-        /// <summary>
-        /// Initializes a new <see cref="XLAddress"/> struct using a mixed notation.
-        /// </summary>
-        /// <param name="rowNumber">The row number of the cell address.</param>
-        /// <param name="columnLetter">The column letter of the cell address.</param>
-        public XLAddress(IXLWorksheet worksheet, Int32 rowNumber, String columnLetter, Boolean fixedRow, Boolean fixedColumn)
-        {
-            this.Worksheet = worksheet;
-            this.rowNumber = rowNumber;
-            this.columnNumber = 0;
-            this.columnLetter = columnLetter;
-            this.fixedColumn = fixedColumn;
-            this.fixedRow = fixedRow;
-            hashCode = rowNumber ^ ColumnNumber;
-        }
-
-
-        /// <summary>
-        /// Initializes a new <see cref="XLAddress"/> struct using A1 notation.
-        /// </summary>
-        /// <param name="cellAddressString">The cell address.</param>
-        public XLAddress(IXLWorksheet worksheet, String cellAddressString)
-        {
-            this.Worksheet = worksheet;
-
-            fixedColumn = cellAddressString[0] == '$';
+            var fixedColumn = cellAddressString[0] == '$';
             Int32 startPos;
             if (fixedColumn)
+            {
                 startPos = 1;
+            }
             else
+            {
                 startPos = 0;
+            }
 
-            Int32 rowPos = startPos;
+            int rowPos = startPos;
             while (cellAddressString[rowPos] > '9')
+            {
                 rowPos++;
+            }
 
-            fixedRow = cellAddressString[rowPos] == '$';
-
+            var fixedRow = cellAddressString[rowPos] == '$';
+            string columnLetter = null;
+            int rowNumber;
             if (fixedRow)
             {
-                if (fixedColumn)
-                    columnLetter = cellAddressString.Substring(startPos, rowPos - 1);
-                else
-                    columnLetter = cellAddressString.Substring(startPos, rowPos);
 
-                rowNumber = Int32.Parse(cellAddressString.Substring(rowPos + 1), nfi);
+                if (fixedColumn)
+                {
+                    columnLetter = cellAddressString.Substring(startPos, rowPos - 1);
+                }
+                else
+                {
+                    columnLetter = cellAddressString.Substring(startPos, rowPos);
+                }
+
+                rowNumber = Int32.Parse(cellAddressString.Substring(rowPos + 1), ms_nfi);
             }
             else
             {
                 if (fixedColumn)
+                {
                     columnLetter = cellAddressString.Substring(startPos, rowPos - 1);
+                }
                 else
+                {
                     columnLetter = cellAddressString.Substring(startPos, rowPos);
+                }
 
-                rowNumber = Int32.Parse(cellAddressString.Substring(rowPos), nfi);
+                rowNumber = Int32.Parse(cellAddressString.Substring(rowPos), ms_nfi);
             }
-
-            columnNumber = 0;
-
-            hashCode =  rowNumber ^ ColumnNumber;
+            return new XLAddress(worksheet, rowNumber, columnLetter, fixedRow, fixedColumn);
         }
-        #endregion
 
-        #region Static
-        private static NumberFormatInfo nfi = CultureInfo.InvariantCulture.NumberFormat;
-        private static readonly Int32 twoT26 = 26 * 26;
+        private static readonly NumberFormatInfo ms_nfi = CultureInfo.InvariantCulture.NumberFormat;
+        private const Int32 TwoT26 = 26 * 26;
         /// <summary>
-        /// Gets the column number of a given column letter.
+        /// 	Gets the column number of a given column letter.
         /// </summary>
-        /// <param name="columnLetter">The column letter to translate into a column number.</param>
+        /// <param name = "columnLetter">The column letter to translate into a column number.</param>
         public static Int32 GetColumnNumberFromLetter(String columnLetter)
         {
             if (columnLetter[0] <= '9')
-                return Int32.Parse(columnLetter, nfi);
+            {
+                return Int32.Parse(columnLetter, ms_nfi);
+            }
 
             columnLetter = columnLetter.ToUpper();
             var length = columnLetter.Length;
@@ -108,24 +77,20 @@
             {
                 return Convert.ToByte(columnLetter[0]) - 64;
             }
-            else if (length == 2)
+            if (length == 2)
             {
                 return
-                    ((Convert.ToByte(columnLetter[0]) - 64) * 26) +
-                    (Convert.ToByte(columnLetter[1]) - 64);
-
+                        ((Convert.ToByte(columnLetter[0]) - 64) * 26) +
+                        (Convert.ToByte(columnLetter[1]) - 64);
             }
-            else if (length == 3)
+            if (length == 3)
             {
                 return
-                    ((Convert.ToByte(columnLetter[0]) - 64) * twoT26) +
-                    ((Convert.ToByte(columnLetter[1]) - 64) * 26) +
-                    (Convert.ToByte(columnLetter[2]) - 64);
+                        ((Convert.ToByte(columnLetter[0]) - 64) * TwoT26) +
+                        ((Convert.ToByte(columnLetter[1]) - 64) * 26) +
+                        (Convert.ToByte(columnLetter[2]) - 64);
             }
-            else
-            {
-                throw new ApplicationException("Column Length must be between 1 and 3.");
-            }
+            throw new ApplicationException("Column Length must be between 1 and 3.");
         }
 
         public static Boolean IsValidColumn(String column)
@@ -134,29 +99,31 @@
             {
                 return false;
             }
-            else
+
+            Boolean retVal = true;
+            String theColumn = column.ToUpper();
+            for (Int32 i = 0; i < column.Length; i++)
             {
-                Boolean retVal = true;
-                String theColumn = column.ToUpper();
-                for (Int32 i = 0; i < column.Length; i++)
+                if (theColumn[i] < 'A' || theColumn[i] > 'Z' || (i == 2 && theColumn[i] > 'D'))
                 {
-                    if (theColumn[i] < 'A' || theColumn[i] > 'Z' || (i == 2 && theColumn[i] > 'D'))
-                    {
-                        retVal = false;
-                        break;
-                    }
+                    retVal = false;
+                    break;
                 }
-                return retVal;
             }
+            return retVal;
         }
 
         public static Boolean IsValidRow(String rowString)
         {
             Int32 row;
             if (Int32.TryParse(rowString, out row))
+            {
                 return row > 0 && row <= XLWorksheet.MaxNumberOfRows;
+            }
             else
+            {
                 return false;
+            }
         }
 
         public static Boolean IsValidA1Address(String address)
@@ -165,36 +132,37 @@
             Int32 rowPos = 0;
             Int32 addressLength = address.Length;
             while (rowPos < addressLength && (address[rowPos] > '9' || address[rowPos] < '0'))
+            {
                 rowPos++;
+            }
 
-            return 
-                   rowPos < addressLength
-                && IsValidRow(address.Substring(rowPos))
-                && IsValidColumn(address.Substring(0, rowPos));
+            return
+                    rowPos < addressLength
+                    && IsValidRow(address.Substring(rowPos))
+                    && IsValidColumn(address.Substring(0, rowPos));
         }
 
-
         /// <summary>
-        /// Gets the column letter of a given column number.
+        /// 	Gets the column letter of a given column number.
         /// </summary>
-        /// <param name="columnNumber">The column number to translate into a column letter.</param>
+        /// <param name = "columnNumber">The column number to translate into a column letter.</param>
         public static String GetColumnLetterFromNumber(Int32 columnNumber)
         {
             String s = String.Empty;
             for (
-                Int32 i = Convert.ToInt32(
-                    Math.Log(
-                        Convert.ToDouble(
-                            25 * (
-                                Convert.ToDouble(columnNumber)
-                                + 1
-                            )
-                         )
-                     ) / Math.Log(26)
-                 ) - 1
-                ; i >= 0
-                ; i--
-                )
+                    Int32 i = Convert.ToInt32(
+                            Math.Log(
+                                    Convert.ToDouble(
+                                            25 * (
+                                                       Convert.ToDouble(columnNumber)
+                                                       + 1
+                                               )
+                                            )
+                                    ) / Math.Log(26)
+                                      ) - 1
+                    ; i >= 0
+                    ; i--
+                    )
             {
                 Int32 x = Convert.ToInt32(Math.Pow(26, i + 1) - 1) / 25 - 1;
                 if (columnNumber > x)
@@ -209,16 +177,20 @@
         {
             Int32 rowPos = 1;
             while (cellAddressString[rowPos] > '9')
+            {
                 rowPos++;
+            }
 
-                return Int32.Parse(cellAddressString.Substring(rowPos), nfi);
+            return Int32.Parse(cellAddressString.Substring(rowPos), ms_nfi);
         }
 
         public static Int32 GetColumnNumberFromAddress1(String cellAddressString)
         {
             Int32 rowPos = 0;
             while (cellAddressString[rowPos] > '9')
+            {
                 rowPos++;
+            }
 
             return GetColumnNumberFromLetter(cellAddressString.Substring(0, rowPos));
         }
@@ -227,15 +199,17 @@
         {
             Int32 rowPos = 1;
             while (cellAddressString[rowPos] > '9')
+            {
                 rowPos++;
+            }
 
             if (cellAddressString[rowPos] == '$')
             {
-                return Int32.Parse(cellAddressString.Substring(rowPos + 1), nfi);
+                return Int32.Parse(cellAddressString.Substring(rowPos + 1), ms_nfi);
             }
             else
             {
-                return Int32.Parse(cellAddressString.Substring(rowPos), nfi);
+                return Int32.Parse(cellAddressString.Substring(rowPos), ms_nfi);
             }
         }
 
@@ -243,14 +217,20 @@
         {
             Int32 startPos;
             if (cellAddressString[0] == '$')
+            {
                 startPos = 1;
+            }
             else
+            {
                 startPos = 0;
+            }
 
             Int32 rowPos = startPos;
             while (cellAddressString[rowPos] > '9')
+            {
                 rowPos++;
-            
+            }
+
             if (cellAddressString[rowPos] == '$')
             {
                 return GetColumnNumberFromLetter(cellAddressString.Substring(startPos, rowPos - 1));
@@ -260,140 +240,179 @@
                 return GetColumnNumberFromLetter(cellAddressString.Substring(startPos, rowPos));
             }
         }
-
-
         #endregion
+        #region Private fields
+        private bool m_fixedRow;
+        private bool m_fixedColumn;
+        private string m_columnLetter;
 
+        private readonly int m_rowNumber;
+        private readonly int m_columnNumber;
+        private readonly int m_hashCode;
+        #endregion
+        #region Constructors
+        /// <summary>
+        /// 	Initializes a new <see cref = "XLAddress" /> struct using a mixed notation.
+        /// </summary>
+        /// <param name = "worksheet"></param>
+        /// <param name = "rowNumber">The row number of the cell address.</param>
+        /// <param name = "columnLetter">The column letter of the cell address.</param>
+        /// <param name = "fixedRow"></param>
+        /// <param name = "fixedColumn"></param>
+        public XLAddress(IXLWorksheet worksheet, int rowNumber, string columnLetter, bool fixedRow, bool fixedColumn)
+            : this(worksheet, rowNumber, GetColumnNumberFromLetter(columnLetter), fixedRow, fixedColumn)
+        {
+            m_columnLetter = columnLetter;
+        }
+
+        /// <summary>
+        /// 	Initializes a new <see cref = "XLAddress" /> struct using R1C1 notation.
+        /// </summary>
+        /// <param name = "worksheet"></param>
+        /// <param name = "rowNumber">The row number of the cell address.</param>
+        /// <param name = "columnNumber">The column number of the cell address.</param>
+        /// <param name = "fixedRow"></param>
+        /// <param name = "fixedColumn"></param>
+        public XLAddress(IXLWorksheet worksheet, int rowNumber, int columnNumber, bool fixedRow, bool fixedColumn)
+            
+        {
+            Worksheet = worksheet;
+
+            m_rowNumber = rowNumber;
+            m_columnNumber = columnNumber;
+            m_columnLetter = null;
+            m_fixedColumn = fixedColumn;
+            m_fixedRow = fixedRow;
+
+            m_hashCode = m_rowNumber ^ m_columnNumber;
+        }
+        #endregion
         #region Properties
-
         public IXLWorksheet Worksheet { get; internal set; }
 
-        private Boolean fixedRow;
         public Boolean FixedRow
         {
-            get { return fixedRow; }
-            set { fixedRow = value; }
+            get { return m_fixedRow; }
+            set { m_fixedRow = value; }
         }
 
-        private Boolean fixedColumn;
         public Boolean FixedColumn
         {
-            get { return fixedColumn; }
-            set { fixedColumn = value; }
+            get { return m_fixedColumn; }
+            set { m_fixedColumn = value; }
         }
 
-        private Int32 rowNumber;
         /// <summary>
-        /// Gets the row number of this address.
+        /// 	Gets the row number of this address.
         /// </summary>
         public Int32 RowNumber
         {
-            get { return rowNumber; }
-            private set { rowNumber = value; }
+            get { return m_rowNumber; }
         }
 
-        private Int32 columnNumber;
         /// <summary>
-        /// Gets the column number of this address.
+        /// 	Gets the column number of this address.
         /// </summary>
         public Int32 ColumnNumber
         {
-            get 
+            get
             {
-                if (columnNumber == 0)
-                    columnNumber = GetColumnNumberFromLetter(columnLetter);
-
-                return columnNumber; 
+                return m_columnNumber;
             }
-            private set { columnNumber = value; }
         }
 
-        private String columnLetter;
         /// <summary>
-        /// Gets the column letter(s) of this address.
+        /// 	Gets the column letter(s) of this address.
         /// </summary>
         public String ColumnLetter
         {
-            get 
-            { 
-                if (columnLetter == null)
-                    columnLetter = GetColumnLetterFromNumber(columnNumber);
-
-                return columnLetter; 
-            }
-            private set { columnLetter = value; }
+            get { return m_columnLetter ?? (m_columnLetter = GetColumnLetterFromNumber(m_columnNumber)); }
         }
-
         #endregion
-
         #region Overrides
         public override string ToString()
         {
             String retVal = ColumnLetter;
-            if (fixedColumn)
+            if (m_fixedColumn)
+            {
                 retVal = "$" + retVal;
-            if (fixedRow)
+            }
+            if (m_fixedRow)
+            {
                 retVal += "$";
-            retVal += rowNumber.ToStringLookup();
+            }
+            retVal += m_rowNumber.ToStringLookup();
             return retVal;
         }
 
         public String ToString(XLReferenceStyle referenceStyle)
         {
             if (referenceStyle == XLReferenceStyle.A1)
-                return ColumnLetter + rowNumber.ToStringLookup();
-            else if (referenceStyle == XLReferenceStyle.R1C1)
-                return rowNumber.ToStringLookup() + "," + ColumnNumber;
-            else
-                if ((Worksheet as XLWorksheet).Internals.Workbook.ReferenceStyle == XLReferenceStyle.R1C1)
-                    return rowNumber.ToStringLookup() + "," + ColumnNumber;
-                else
-                    return ColumnLetter + rowNumber.ToStringLookup();
+            {
+                return ColumnLetter + m_rowNumber.ToStringLookup();
+            }
+            if (referenceStyle == XLReferenceStyle.R1C1)
+            {
+                return m_rowNumber.ToStringLookup() + "," + ColumnNumber;
+            }
+            if ((Worksheet as XLWorksheet).Internals.Workbook.ReferenceStyle == XLReferenceStyle.R1C1)
+            {
+                return m_rowNumber.ToStringLookup() + "," + ColumnNumber;
+            }
+            return ColumnLetter + m_rowNumber.ToStringLookup();
         }
         #endregion
-
         #region Methods
         public string GetTrimmedAddress()
         {
-            return ColumnLetter + rowNumber.ToStringLookup();
+            return ColumnLetter + m_rowNumber.ToStringLookup();
         }
 
         public string ToStringRelative()
         {
-            return ColumnLetter + rowNumber.ToStringLookup();
+            return ColumnLetter + m_rowNumber.ToStringLookup();
         }
 
         public string ToStringFixed()
         {
-            return "$" + ColumnLetter + "$" + rowNumber.ToStringLookup();
+            return "$" + ColumnLetter + "$" + m_rowNumber.ToStringLookup();
         }
-
         #endregion
-
         #region Operator Overloads
-
         public static XLAddress operator +(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
         {
-            return new XLAddress(xlCellAddressLeft.Worksheet, xlCellAddressLeft.RowNumber + xlCellAddressRight.RowNumber, xlCellAddressLeft.ColumnNumber + xlCellAddressRight.ColumnNumber,
-                xlCellAddressLeft.fixedRow, xlCellAddressLeft.fixedColumn);
+            return new XLAddress(xlCellAddressLeft.Worksheet,
+                                 xlCellAddressLeft.RowNumber + xlCellAddressRight.RowNumber,
+                                 xlCellAddressLeft.ColumnNumber + xlCellAddressRight.ColumnNumber,
+                                 xlCellAddressLeft.m_fixedRow,
+                                 xlCellAddressLeft.m_fixedColumn);
         }
 
         public static XLAddress operator -(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
         {
-            return new XLAddress(xlCellAddressLeft.Worksheet, xlCellAddressLeft.RowNumber - xlCellAddressRight.RowNumber, xlCellAddressLeft.ColumnNumber - xlCellAddressRight.ColumnNumber,
-                xlCellAddressLeft.fixedRow, xlCellAddressLeft.fixedColumn);
+            return new XLAddress(xlCellAddressLeft.Worksheet,
+                                 xlCellAddressLeft.RowNumber - xlCellAddressRight.RowNumber,
+                                 xlCellAddressLeft.ColumnNumber - xlCellAddressRight.ColumnNumber,
+                                 xlCellAddressLeft.m_fixedRow,
+                                 xlCellAddressLeft.m_fixedColumn);
         }
 
         public static XLAddress operator +(XLAddress xlCellAddressLeft, Int32 right)
         {
-            return new XLAddress(xlCellAddressLeft.Worksheet, xlCellAddressLeft.RowNumber + right, xlCellAddressLeft.ColumnNumber + right,
-                xlCellAddressLeft.fixedRow, xlCellAddressLeft.fixedColumn);
+            return new XLAddress(xlCellAddressLeft.Worksheet,
+                                 xlCellAddressLeft.RowNumber + right,
+                                 xlCellAddressLeft.ColumnNumber + right,
+                                 xlCellAddressLeft.m_fixedRow,
+                                 xlCellAddressLeft.m_fixedColumn);
         }
 
         public static XLAddress operator -(XLAddress xlCellAddressLeft, Int32 right)
         {
-            return new XLAddress(xlCellAddressLeft.Worksheet, xlCellAddressLeft.RowNumber - right, xlCellAddressLeft.ColumnNumber - right,
-                xlCellAddressLeft.fixedRow, xlCellAddressLeft.fixedColumn);
+            return new XLAddress(xlCellAddressLeft.Worksheet,
+                                 xlCellAddressLeft.RowNumber - right,
+                                 xlCellAddressLeft.ColumnNumber - right,
+                                 xlCellAddressLeft.m_fixedRow,
+                                 xlCellAddressLeft.m_fixedColumn);
         }
 
         public static Boolean operator ==(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
@@ -405,35 +424,9 @@
         {
             return !(xlCellAddressLeft == xlCellAddressRight);
         }
-
-        public static Boolean operator >(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
-        {
-            return  (xlCellAddressLeft.RowNumber > xlCellAddressRight.RowNumber 
-                || xlCellAddressLeft.ColumnNumber > xlCellAddressRight.ColumnNumber);
-        }
-
-        public static Boolean operator <(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
-        {
-            return (xlCellAddressLeft.RowNumber < xlCellAddressRight.RowNumber 
-                || xlCellAddressLeft.ColumnNumber < xlCellAddressRight.ColumnNumber);
-        }
-
-        public static Boolean operator >=(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
-        {
-            return xlCellAddressLeft == xlCellAddressRight || xlCellAddressLeft > xlCellAddressRight;
-        }
-
-        public static Boolean operator <=(XLAddress xlCellAddressLeft, XLAddress xlCellAddressRight)
-        {
-            return xlCellAddressLeft == xlCellAddressRight || xlCellAddressLeft < xlCellAddressRight;
-        }
-
         #endregion
-
         #region Interface Requirements
-
         #region IEqualityComparer<XLCellAddress> Members
-
         public Boolean Equals(IXLAddress x, IXLAddress y)
         {
             return x == y;
@@ -444,72 +437,53 @@
             return obj.GetHashCode();
         }
 
-        new public Boolean Equals(Object x, Object y)
+        public new Boolean Equals(Object x, Object y)
         {
             return x == y;
         }
 
         public Int32 GetHashCode(Object obj)
         {
-            return ((XLAddress)obj).GetHashCode();
+            return (obj).GetHashCode();
         }
 
-        int hashCode;
+        
         public override Int32 GetHashCode()
         {
-            return hashCode;
+            return m_hashCode;
         }
-
         #endregion
-
         #region IEquatable<XLCellAddress> Members
-
         public Boolean Equals(IXLAddress other)
         {
             var right = other as XLAddress;
-            if (hashCode != right.hashCode)
+            if (m_hashCode != right.m_hashCode)
+            {
                 return false;
+            }
 
-            if (this.rowNumber == right.rowNumber)
-                if (right.columnNumber > 0)
-                    return this.ColumnNumber == right.columnNumber;
+            if (m_rowNumber == right.m_rowNumber)
+            {
+                if (right.m_columnNumber > 0)
+                {
+                    return ColumnNumber == right.m_columnNumber;
+                }
                 else
-                    return this.ColumnLetter == right.columnLetter;
+                {
+                    return ColumnLetter == right.m_columnLetter;
+                }
+            }
             else
+            {
                 return false;
+            }
         }
 
         public override Boolean Equals(Object other)
         {
-            return Equals((XLAddress)other);
+            return Equals((XLAddress) other);
         }
-
         #endregion
-
-        #region IComparable Members
-
-        public Int32 CompareTo(object obj)
-        {
-            var other = (XLAddress)obj;
-            if (this == other)
-                return 0;
-            else if (this > other)
-                return 1;
-            else
-                return -1;
-        }
-
-        #endregion
-
-        #region IComparable<XLCellAddress> Members
-
-        public Int32 CompareTo(IXLAddress other)
-        {
-            return CompareTo((Object)other);
-        }
-
-        #endregion
-
         #endregion
     }
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook.cs
index 66fc193..801b229 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook.cs
@@ -150,6 +150,7 @@
         /// </summary>
         public void SaveAs(String file)
         {
+            PathHelper.CreateDirectory(Path.GetDirectoryName(file));
             if (loadSource == XLLoadSource.New)
             {
                 if (File.Exists(file))
diff --git a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
index ff2805a..8abc8cf 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Excel/XLWorkbook_Save.cs
@@ -92,6 +92,7 @@
 
         private void CreatePackage(String filePath)
         {
+            PathHelper.CreateDirectory(Path.GetDirectoryName(filePath));
             SpreadsheetDocument package;
             if (File.Exists(filePath))
                 package = SpreadsheetDocument.Open(filePath, true);
@@ -1768,7 +1769,7 @@
                 foreach (var cell in row.Elements<Cell>())
                 {
                     var cellReference = cell.CellReference;
-                    if ((xlWorksheet as XLWorksheet).Internals.CellsCollection.Deleted.ContainsKey(new XLAddress(xlWorksheet, cellReference)))
+                    if ((xlWorksheet as XLWorksheet).Internals.CellsCollection.Deleted.ContainsKey(XLAddress.Create(xlWorksheet, cellReference)))
                         cellsToRemove.Add(cell);
                 }
                 cellsToRemove.ForEach(cell => row.RemoveChild(cell));
diff --git a/ClosedXML/ClosedXML/ClosedXML/Extensions.cs b/ClosedXML/ClosedXML/ClosedXML/Extensions.cs
index 8b5bbe9..bad6ffa 100644
--- a/ClosedXML/ClosedXML/ClosedXML/Extensions.cs
+++ b/ClosedXML/ClosedXML/ClosedXML/Extensions.cs
@@ -5,7 +5,6 @@
 using System.Drawing;
 using System.Globalization;
 
-
 [assembly: CLSCompliantAttribute(true)]
 namespace ClosedXML
 {
@@ -18,7 +17,7 @@
                 action(item);
         }
 
-        static char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+        private static readonly char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
         public static String ToHex(this Color color)
         {
@@ -128,8 +127,8 @@
 
     public static class IntegerExtensions
     {
-        private static NumberFormatInfo nfi = CultureInfo.InvariantCulture.NumberFormat;
-        private static Dictionary<Int32, String> intToString = new Dictionary<int, string>();
+        private static readonly NumberFormatInfo nfi = CultureInfo.InvariantCulture.NumberFormat;
+        private static readonly Dictionary<Int32, String> intToString = new Dictionary<int, string>();
         public static String ToStringLookup(this Int32 value)
         {
             if (!intToString.ContainsKey(value))
@@ -139,7 +138,5 @@
             return intToString[value];
         }
     }
-
-
 }
 
diff --git a/ClosedXML/ClosedXML/ClosedXML/PathHelper.cs b/ClosedXML/ClosedXML/ClosedXML/PathHelper.cs
new file mode 100644
index 0000000..702d955
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML/PathHelper.cs
@@ -0,0 +1,254 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace ClosedXML
+{
+    /// <summary>
+    ///   Help methods for work with files
+    /// </summary>
+    internal static class PathHelper
+    {
+        private static readonly Regex ms_checkValidAbsolutePathRegEx = new Regex(
+                "^(([a-zA-Z]\\:)|\\\\)(\\\\|(\\\\[^\\n\\r\\t/:*?<>\\\"|]*)+)$",
+                RegexOptions.IgnoreCase
+                | RegexOptions.Singleline
+                | RegexOptions.CultureInvariant
+                | RegexOptions.Compiled
+                );
+        /// <summary>
+        ///   Can check only .\dfdfd\dfdf\dfdf or ..\..\gfhfgh\fghfh
+        /// </summary>
+        private static readonly Regex ms_checkValidRelativePathRegEx = new Regex(
+                "^(\\.\\.|\\.)(\\\\|(\\\\[^\\n\\r\\t/:*?<>\\\"|]*)+)$",
+                RegexOptions.IgnoreCase
+                | RegexOptions.Multiline
+                | RegexOptions.CultureInvariant
+                | RegexOptions.Compiled
+                );
+
+        private static readonly object ms_syncAbsolutePathObj = new object();
+
+        /// <summary>
+        ///   Gets data and time string stamp for file name
+        /// </summary>
+        /// <returns></returns>
+        public static string GetTimeStamp()
+        {
+            return GetTimeStamp(DateTime.Now);
+        }
+        /// <summary>
+        ///   Gets data and time string stamp for file name
+        /// </summary>
+        /// <returns></returns>
+        public static string GetTimeStamp(DateTime dateTime)
+        {
+            return dateTime.ToString("ddMMMyyyy_HHmmss", DateTimeFormatInfo.InvariantInfo);
+        }
+        /// <summary>
+        ///   Safety delete file(with try block)
+        /// </summary>
+        /// <param name = "fileName">file name</param>
+        public static void SafetyDeleteFile(string fileName)
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(fileName) && File.Exists(fileName))
+                {
+                    File.Delete(fileName);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.Fail("Error during file deleting. Error message:" + ex.Message);
+            }
+        }
+        /// <summary>
+        ///   Replace all not implemented symbols to '_'
+        /// </summary>
+        /// <param name = "fileName">input filename</param>
+        /// <returns></returns>
+        public static string NormalizeFileName(string fileName)
+        {
+            char[] invalidCharacters = Path.GetInvalidFileNameChars();
+            #region Replace begin space
+            string result = fileName.TrimStart(' ');
+            if (result.Length < fileName.Length)
+            {
+                result = new string('_', fileName.Length - result.Length) + result;
+            }
+            #endregion
+            foreach (char curChar in invalidCharacters)
+            {
+                result = result.Replace(curChar, '_');
+            }
+            return result;
+        }
+
+        public static string NormalizePathName(string fileName)
+        {
+            char[] invalidCharacters = Path.GetInvalidPathChars();
+            string result = fileName.TrimStart(' ');
+            foreach (char curChar in invalidCharacters)
+            {
+                result = result.Replace(curChar, '_');
+            }
+            return result;
+        }
+        /// <summary>
+        ///   ValidatePath file or diretory path
+        /// </summary>
+        /// <param name = "path"></param>
+        /// <param name = "type">path type</param>
+        /// <returns></returns>
+        public static bool ValidatePath(string path, PathTypes type)
+        {
+            bool _result = false;
+            if ((type & PathTypes.Absolute) == PathTypes.Absolute)
+            {
+                _result |= ms_checkValidAbsolutePathRegEx.IsMatch(path);
+            }
+            if ((type & PathTypes.Relative) == PathTypes.Relative)
+            {
+                _result |= ms_checkValidRelativePathRegEx.IsMatch(path);
+            }
+            return _result;
+        }
+
+        /// <summary>
+        ///   ValidatePath file or diretory path
+        /// </summary>
+        /// <param name = "fileName"></param>
+        /// <returns></returns>
+        public static bool ValidateFileName(string fileName)
+        {
+            return fileName.LastIndexOfAny(Path.GetInvalidFileNameChars()) < 0;
+        }
+
+        public static string EvaluateRelativePath(string mainDirPath, string absoluteFilePath)
+        {
+            string[] firstPathParts = mainDirPath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);
+            string[] secondPathParts = absoluteFilePath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);
+
+            int sameCounter = 0;
+            int partsCount = Math.Min(firstPathParts.Length, secondPathParts.Length);
+            for (int i = 0; i < partsCount; i++)
+            {
+                if (!firstPathParts[i].ToLower().Equals(secondPathParts[i].ToLower()))
+                {
+                    break;
+                }
+                sameCounter++;
+            }
+
+            if (sameCounter == 0)
+            {
+                return absoluteFilePath;
+            }
+
+            string newPath = string.Empty;
+            for (int i = sameCounter; i < firstPathParts.Length; i++)
+            {
+                if (i > sameCounter)
+                {
+                    newPath += Path.DirectorySeparatorChar;
+                }
+                newPath += "..";
+            }
+            if (newPath.Length == 0)
+            {
+                newPath = ".";
+            }
+            for (int i = sameCounter; i < secondPathParts.Length; i++)
+            {
+                newPath += Path.DirectorySeparatorChar;
+                newPath += secondPathParts[i];
+            }
+            return newPath;
+        }
+
+        public static string EvaluateAbsolutePath(string rootPath, string relativePath)
+        {
+            lock (ms_syncAbsolutePathObj)
+            {
+                string _temp = Environment.CurrentDirectory;
+                Environment.CurrentDirectory = rootPath;
+                string _result = Path.GetFullPath(relativePath);
+                Environment.CurrentDirectory = _temp;
+                return _result;
+            }
+        }
+
+        public static bool TryCreateFile(string filePath, out string message)
+        {
+            #region Check
+            if (string.IsNullOrEmpty(filePath))
+            {
+                throw new ArgumentNullException("filePath");
+            }
+            #endregion
+            try
+            {
+                if (File.Exists(filePath))
+                {
+                    message = null;
+                    return true;
+                }
+
+                using (FileStream _stream = new FileStream(filePath,
+                                                           FileMode.Create,
+                                                           FileAccess.ReadWrite,
+                                                           FileShare.Read,
+                                                           1024,
+                                                           FileOptions.DeleteOnClose))
+                {
+                }
+            }
+            catch (Exception exc)
+            {
+                message = exc.Message;
+                return false;
+            }
+
+            message = null;
+            return true;
+        }
+
+        public static string CreateDirectory(string path)
+        {
+            try
+            {
+                var info = new DirectoryInfo(path);
+                if (!info.Exists)
+                {
+                    info.Create();
+                }
+            }
+            catch
+            {
+            }
+            return path;
+        }
+
+        public static void OpenFileFolder(string filePath)
+        {
+            string cmdLine = string.Format("/select,\"{0}\"", filePath);
+            Process.Start(@"explorer.exe", cmdLine);
+        }
+
+        public static void OpenFile(string filePath)
+        {
+            Process.Start(filePath);
+        }
+
+        [Flags]
+        public enum PathTypes
+        {
+            None = 0,
+            Absolute = 1,
+            Relative = 2
+        }
+    }
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Examples/..svnbridge/.svnbridge b/ClosedXML/ClosedXML/ClosedXML_Examples/..svnbridge/.svnbridge
new file mode 100644
index 0000000..bdf168c
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML_Examples/..svnbridge/.svnbridge
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?><ItemProperties xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Properties><Property><Name>svn:ignore</Name><Value>bin
+obj
+</Value></Property></Properties></ItemProperties>
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Net3.5/..svnbridge/.svnbridge b/ClosedXML/ClosedXML/ClosedXML_Net3.5/..svnbridge/.svnbridge
new file mode 100644
index 0000000..bdf168c
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML_Net3.5/..svnbridge/.svnbridge
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?><ItemProperties xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Properties><Property><Name>svn:ignore</Name><Value>bin
+obj
+</Value></Property></Properties></ItemProperties>
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj b/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
index b0f1ce9..6c49d43 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML_Net3.5/ClosedXML_Net3.5.csproj
@@ -514,6 +514,9 @@
     <Compile Include="..\ClosedXML\Extensions.cs">
       <Link>Extensions.cs</Link>
     </Compile>
+    <Compile Include="..\ClosedXML\PathHelper.cs">
+      <Link>PathHelper.cs</Link>
+    </Compile>
     <Compile Include="Excel\Cells\XLCell_DotNetSpecific.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/ClosedXML/ClosedXML/ClosedXML_Sandbox/..svnbridge/.svnbridge b/ClosedXML/ClosedXML/ClosedXML_Sandbox/..svnbridge/.svnbridge
new file mode 100644
index 0000000..bdf168c
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML_Sandbox/..svnbridge/.svnbridge
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?><ItemProperties xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><Properties><Property><Name>svn:ignore</Name><Value>bin
+obj
+</Value></Property></Properties></ItemProperties>
\ No newline at end of file