diff --git a/CSafeRefactoring/CSafeRefactoring.Vsix/CSafeRefactoring.Vsix.csproj b/CSafeRefactoring/CSafeRefactoring.Vsix/CSafeRefactoring.Vsix.csproj
index 3861c4f..4544b29 100644
--- a/CSafeRefactoring/CSafeRefactoring.Vsix/CSafeRefactoring.Vsix.csproj
+++ b/CSafeRefactoring/CSafeRefactoring.Vsix/CSafeRefactoring.Vsix.csproj
@@ -17,7 +17,7 @@
     <AssemblyName>CSafeRefactoring.Vsix</AssemblyName>
     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
     <GeneratePkgDefFile>false</GeneratePkgDefFile>
-    <IncludeAssemblyInVSIXContainer>false</IncludeAssemblyInVSIXContainer>
+    <IncludeAssemblyInVSIXContainer>true</IncludeAssemblyInVSIXContainer>
     <IncludeDebugSymbolsInVSIXContainer>false</IncludeDebugSymbolsInVSIXContainer>
     <IncludeDebugSymbolsInLocalVSIXDeployment>false</IncludeDebugSymbolsInLocalVSIXDeployment>
     <CopyBuildOutputToOutputDirectory>false</CopyBuildOutputToOutputDirectory>
@@ -41,6 +41,8 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <CopyVsixExtensionFiles>True</CopyVsixExtensionFiles>
+    <CopyVsixExtensionLocation>C:/temp</CopyVsixExtensionLocation>
   </PropertyGroup>
   <PropertyGroup>
     <StartAction>Program</StartAction>
@@ -58,6 +60,18 @@
       <Name>CSafeRefactoring</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="Icons\CSafe.png">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <IncludeInVSIX>true</IncludeInVSIX>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Icons\CSafe.ico">
+      <IncludeInVSIX>true</IncludeInVSIX>
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.ico b/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.ico
new file mode 100644
index 0000000..704f229
Binary files /dev/null and b/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.ico differ
diff --git a/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.png b/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.png
new file mode 100644
index 0000000..b95b1a9
Binary files /dev/null and b/CSafeRefactoring/CSafeRefactoring.Vsix/Icons/CSafe.png differ
diff --git a/CSafeRefactoring/CSafeRefactoring.Vsix/source.extension.vsixmanifest b/CSafeRefactoring/CSafeRefactoring.Vsix/source.extension.vsixmanifest
index 8160038..d27a977 100644
--- a/CSafeRefactoring/CSafeRefactoring.Vsix/source.extension.vsixmanifest
+++ b/CSafeRefactoring/CSafeRefactoring.Vsix/source.extension.vsixmanifest
@@ -1,11 +1,13 @@
 <?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
   <Metadata>
-    <Identity Id="CSafeRefactoring.Kentico software.c8750bdf-1661-4112-95e5-3fe2bbf4ebf3" Version="1.2.1" Language="en-US" Publisher="StanislavS"/>
+    <Identity Id="CSafeRefactoring.c8750bdf-1661-4112-95e5-3fe2bbf4ebf3" Version="2.1.4" Language="en-US" Publisher="StanislavS"/>
     <DisplayName>CSafeRefactoring</DisplayName>
     <Description xml:space="preserve">Kentico CSafe methods refactoring extension.</Description>
+    <Icon>Icons\CSafe.ico</Icon>
+    <PreviewImage>Icons\CSafe.png</PreviewImage>
   </Metadata>
-  <Installation>
+  <Installation AllUsers="true">
     <InstallationTarget Version="[14.0,]" Id="Microsoft.VisualStudio.Pro" />
   </Installation>
   <Dependencies>
diff --git a/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.csproj b/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.csproj
index 9fb9f92..dc79865 100644
--- a/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.csproj
+++ b/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.csproj
@@ -33,6 +33,7 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="CodeRefactoringProviderBase.cs" />
     <Compile Include="EndsWithIgnoreCaseRefactoringProvider.cs" />
     <Compile Include="StartsEndsWithRefactoringBase.cs" />
     <Compile Include="EqualsRefactoringBase.cs" />
@@ -42,7 +43,12 @@
     <Compile Include="StartsWithRefactoringProvider.cs" />
     <Compile Include="EqualsRefactoringProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Substituters\EqualsSubstituter.cs" />
+    <Compile Include="Substituters\StartsWithEndsWithSubstituter.cs" />
+    <Compile Include="Substituters\ToLowerSubstituter.cs" />
     <Compile Include="SyntaxTreeCreators\EqualsSyntaxTreeCreator.cs" />
+    <Compile Include="SyntaxTreeCreators\ToLowerSyntaxTreeCreator.cs" />
+    <Compile Include="ToLowerrefactoringProvider.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.nuspec b/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.nuspec
new file mode 100644
index 0000000..7fd4939
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/CSafeRefactoring.nuspec
@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>$id$</id>
+    <version>$version$</version>
+    <title>$title$</title>
+    <authors>$author$</authors>
+    <owners>$author$</owners>
+    <licenseUrl>http://LICENSE_URL_HERE_OR_DELETE_THIS_LINE</licenseUrl>
+    <projectUrl>http://PROJECT_URL_HERE_OR_DELETE_THIS_LINE</projectUrl>
+    <iconUrl>http://ICON_URL_HERE_OR_DELETE_THIS_LINE</iconUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>$description$</description>
+    <releaseNotes>Summary of changes made in this release of the package.</releaseNotes>
+    <copyright>Copyright 2016</copyright>
+    <tags>Tag1 Tag2</tags>
+  </metadata>
+</package>
\ No newline at end of file
diff --git a/CSafeRefactoring/CSafeRefactoring/CodeRefactoringProviderBase.cs b/CSafeRefactoring/CSafeRefactoring/CodeRefactoringProviderBase.cs
new file mode 100644
index 0000000..2725cc1
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/CodeRefactoringProviderBase.cs
@@ -0,0 +1,33 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+
+namespace CSafeRefactoring
+{
+    public abstract class CodeRefactoringProviderBase : CodeRefactoringProvider
+    {
+        private const string ORDINAL_IGNORECASE = "Use StringComparison.OrdinalIgnoreCase";
+        private const string ORDINAL = "Use StringComparison.Ordinal";
+
+        private const string INVARIANTCULTURE_IGNORECASE = "Use StringComparison.InvariantCultureIgnoreCase";
+        private const string INVARIANTCULTURE = "Use StringComparison.InvariantCulture";
+
+        protected abstract string MethodToReplaceName { get; }
+
+        protected abstract bool IgnoreCase { get; }
+
+        protected string GetOrdinalMessage()
+        {
+            return IgnoreCase ? ORDINAL_IGNORECASE : ORDINAL;
+        }
+
+        protected string GetInvariantCultureMessage()
+        {
+            return IgnoreCase ? INVARIANTCULTURE_IGNORECASE : INVARIANTCULTURE;
+        }
+
+        protected bool IsCurrentNodeReplacedMethod(SyntaxNode node)
+        {
+            return node.GetText().ToString() == MethodToReplaceName;
+        }
+    }
+}
diff --git a/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringBase.cs b/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringBase.cs
index ea52d9e..e89c7b0 100644
--- a/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringBase.cs
+++ b/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringBase.cs
@@ -1,81 +1,61 @@
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
-using CSafeRefactoring.SyntaxTreeCreators;
-using Microsoft.CodeAnalysis;
+using CSafeRefactoring.Substituters;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CSafeRefactoring
 {
-    public abstract class EqualsRefactoringBase : CodeRefactoringProvider
+    public abstract class EqualsRefactoringBase : CodeRefactoringProviderBase
     {
-        protected abstract string MethodToReplaceName { get; }
-
-        protected abstract bool IgnoreCase { get; }
-
+        private const string TYPE_ORDINAL = "Ordinal";
+        private const string TYPE_INVARIANTCULTURE = "InvariantCulture";
+        
         public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
-            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
-            var node = root.FindNode(context.Span);
+            var root = await context.Document
+                .GetSyntaxRootAsync(context.CancellationToken)
+                .ConfigureAwait(false);
 
-            var invocationExpr = node;
+            var node = root.FindNode(context.Span);
 
-            if (invocationExpr.GetText().ToString() != MethodToReplaceName)
+            if (!IsCurrentNodeReplacedMethod(node))
             {
                 return;
             }
 
-            var declaration = root.FindNode(context.Span).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();
+            var declaration = root
+                .FindNode(context.Span)
+                .Parent
+                .AncestorsAndSelf()
+                .OfType<InvocationExpressionSyntax>()
+                .First();
 
             if (!AnalyzeAdditionalRestrictions(declaration))
             {
                 return;
             }
 
-            var messageInvariantCulture = IgnoreCase ? "Use StringComparison.InvariantCultureIgnoreCase" : "Use StringComparison.InvariantCulture";
-            var messageOrdinal = IgnoreCase ? "Use StringComparison.OrdinalIgnoreCase" : "Use StringComparison.Ordinal";
-
-            var actionIvariantCulture = CodeAction.Create(messageInvariantCulture, c => FixDocument(context.Document, declaration, c, "InvariantCulture"));
-            var actionOrdinal = CodeAction.Create(messageOrdinal, c => FixDocument(context.Document, declaration, c, "Ordinal"));
-
-            context.RegisterRefactoring(actionIvariantCulture);
-            context.RegisterRefactoring(actionOrdinal);
+            CreateAndRegisterCodeActions(context, declaration);
         }
 
-
-        protected async Task<Document> FixDocument(Document document, InvocationExpressionSyntax invocationExpressionSyntax, CancellationToken cancellationToken, string type)
+        private void CreateAndRegisterCodeActions(CodeRefactoringContext context, InvocationExpressionSyntax declaration)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken);
+            var messageInvariantCulture = GetInvariantCultureMessage();
+            var messageOrdinal = GetOrdinalMessage();
 
-            var memberAccessExpressionSyntax = invocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
-            if (memberAccessExpressionSyntax?.Expression == null)
-            {
-                return document;
-            }
+            var substituter = new EqualsSubstituter(context.Document, declaration, IgnoreCase);
 
-            var leadingTrivia = memberAccessExpressionSyntax.Expression.GetLeadingTrivia();
-            var leftString = memberAccessExpressionSyntax.Expression.WithoutLeadingTrivia();
-            var rightString = invocationExpressionSyntax.ArgumentList.Arguments[0].Expression;
+            var actionIvariantCulture = CodeAction.Create(messageInvariantCulture,
+                cancellationToken => substituter.FixDocument(TYPE_INVARIANTCULTURE, cancellationToken));
+            var actionOrdinal = CodeAction.Create(messageOrdinal,
+                cancellationToken => substituter.FixDocument(TYPE_ORDINAL, cancellationToken));
 
-            var newSyntaxTree = CreateNewOrdinalSyntaxTree(leftString, rightString, leadingTrivia, type);
-            var newRoot = root.ReplaceNode(invocationExpressionSyntax, newSyntaxTree);
-            return document.WithSyntaxRoot(newRoot);
+            context.RegisterRefactoring(actionIvariantCulture);
+            context.RegisterRefactoring(actionOrdinal);
         }
 
-        private InvocationExpressionSyntax CreateNewOrdinalSyntaxTree(ExpressionSyntax leftString, ExpressionSyntax rightString, SyntaxTriviaList leadingTrivia, string type)
-        {
-            var syntaxTreeCreator = new EqualsSyntaxTreeCreator(leftString, rightString);
-            if (IgnoreCase)
-            {
-               return syntaxTreeCreator.Create($"{type}IgnoreCase")
-                    .WithLeadingTrivia(leadingTrivia);
-            }
-
-            return syntaxTreeCreator.Create(type)
-                .WithLeadingTrivia(leadingTrivia);
-        }
 
         protected abstract bool AnalyzeAdditionalRestrictions(InvocationExpressionSyntax invocationExpr);
 
diff --git a/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringProvider.cs b/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringProvider.cs
index 5ecbb29..30c38d7 100644
--- a/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringProvider.cs
+++ b/CSafeRefactoring/CSafeRefactoring/EqualsRefactoringProvider.cs
@@ -12,11 +12,9 @@ public class EqualsRefactoringProvider : EqualsRefactoringBase
 
         protected override bool IgnoreCase => false;
 
-
         protected override bool AnalyzeAdditionalRestrictions(InvocationExpressionSyntax invocationExpr)
         {
             return invocationExpr.ArgumentList.Arguments.Count == 1;
         }
-
     }
 }
\ No newline at end of file
diff --git a/CSafeRefactoring/CSafeRefactoring/StartsEndsWithRefactoringBase.cs b/CSafeRefactoring/CSafeRefactoring/StartsEndsWithRefactoringBase.cs
index e265f31..7f32ba0 100644
--- a/CSafeRefactoring/CSafeRefactoring/StartsEndsWithRefactoringBase.cs
+++ b/CSafeRefactoring/CSafeRefactoring/StartsEndsWithRefactoringBase.cs
@@ -1,156 +1,63 @@
-using System.Diagnostics;
-using System.Linq;
-using System.Threading;
+using System.Linq;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
+using CSafeRefactoring.Substituters;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CSafeRefactoring
 {
-    public abstract class StartsEndsWithRefactoringBase : CodeRefactoringProvider
+    public abstract class StartsEndsWithRefactoringBase : CodeRefactoringProviderBase
     {
-        protected abstract string MethodToReplaceName { get; }
-
         protected abstract string NewMethodName { get; }
 
-
-        protected abstract bool IgnoreCase { get; }
-
         public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
             var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             var node = root.FindNode(context.Span);
 
-            if (node.GetText().ToString() != MethodToReplaceName)
+            if (!IsCurrentNodeReplacedMethod(node))
             {
                 return;
             }
 
-            var declaration =
-                root.FindNode(context.Span).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();
+            var declaration = root
+                .FindNode(context.Span)
+                .Parent
+                .AncestorsAndSelf()
+                .OfType<InvocationExpressionSyntax>()
+                .First();
 
             if (!AnalyzeAdditionalRestrictions(declaration))
             {
                 return;
             }
 
-            var messageInvariantCulture = IgnoreCase
-                ? "Use StringComparison.InvariantCultureIgnoreCase"
-                : "Use StringComparison.InvariantCulture";
-            var messageOrdinal = IgnoreCase ? "Use StringComparison.OrdinalIgnoreCase" : "Use StringComparison.Ordinal";
-
-            var actionIvariantCulture = CodeAction.Create(messageInvariantCulture,
-                c => StringComparisonInvariantCulture(context.Document, declaration, c));
-            var actionOrdinal = CodeAction.Create(messageOrdinal,
-                c => StringComparisonOrdinal(context.Document, declaration, c));
-
-            context.RegisterRefactoring(actionIvariantCulture);
-            context.RegisterRefactoring(actionOrdinal);
-        }
-
-
-        protected async Task<Document> StringComparisonInvariantCulture(Document document,
-            InvocationExpressionSyntax invocationExpr, CancellationToken cancellationToken)
-        {
-            var root = await document.GetSyntaxRootAsync(cancellationToken);
-
-            Debug.WriteLine("root");
-            var memberAccessExpressionSyntax = invocationExpr.Expression as MemberAccessExpressionSyntax;
-            if (memberAccessExpressionSyntax?.Expression == null)
-            {
-                return document;
-            }
-
-            var param1 = memberAccessExpressionSyntax.Expression;
-            var argumentList = invocationExpr.ArgumentList;
-            var param2 = argumentList.Arguments[0].Expression;
-
-            SyntaxNode newRoot;
-
-            if (IgnoreCase)
-            {
-                newRoot = root.ReplaceNode(invocationExpr, Create(param1, param2, "InvariantCultureIgnoreCase"));
-            }
-            else
-            {
-                newRoot = root.ReplaceNode(invocationExpr, Create(param1, param2, "InvariantCulture"));
-            }
-
-            return document.WithSyntaxRoot(newRoot);
+            CreateAndRegisterCodeActions(context, declaration);
         }
 
+        protected abstract bool AnalyzeAdditionalRestrictions(InvocationExpressionSyntax invocationExpr);
 
-        protected async Task<Document> StringComparisonOrdinal(Document document, InvocationExpressionSyntax invocationExpr, CancellationToken cancellationToken)
+      
+        private void CreateAndRegisterCodeActions(CodeRefactoringContext context, InvocationExpressionSyntax declaration)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken);
-
-            var memberAccessExpressionSyntax = invocationExpr.Expression as MemberAccessExpressionSyntax;
-            if (memberAccessExpressionSyntax != null)
-            {
-                var param1 = memberAccessExpressionSyntax.Expression;
-                var argumentList = invocationExpr.ArgumentList;
-                var param2 = argumentList.Arguments[0].Expression;
-
-                SyntaxNode newRoot;
-
-                if (IgnoreCase)
-                {
-                    newRoot = root.ReplaceNode(invocationExpr, Create(param1, param2, "OrdinalIgnoreCase"));
-                }
-                else
-                {
-                    newRoot = root.ReplaceNode(invocationExpr, Create(param1, param2, "Ordinal"));
-                }
+            var messageInvariantCulture = GetInvariantCultureMessage();
+            var messageOrdinal = GetOrdinalMessage();
 
-                var newDocument = document.WithSyntaxRoot(newRoot);
+            var substitutor = new StartsWithEndsWithSubstituter(context.Document, declaration, IgnoreCase, NewMethodName);
 
-                return newDocument;
-            }
-
-            return document;
-        }
+            var actionIvariantCulture = CodeAction.Create(
+                messageInvariantCulture,
+                cancellationToken => substitutor.StringComparisonInvariantCulture(cancellationToken)
+            );
 
+            var actionOrdinal = CodeAction.Create(
+                messageOrdinal, 
+                cancellationToken => substitutor.StringComparisonOrdinal(cancellationToken)
+            );
 
-        protected abstract bool AnalyzeAdditionalRestrictions(InvocationExpressionSyntax invocationExpr);
-
-
-        private InvocationExpressionSyntax Create(ExpressionSyntax leftString, ExpressionSyntax rightString, string type)
-        {
-            return
-                SyntaxFactory.InvocationExpression(
-                        SyntaxFactory.MemberAccessExpression(
-                            SyntaxKind.SimpleMemberAccessExpression,
-                            leftString,
-                            SyntaxFactory.IdentifierName(NewMethodName)
-                        )
-                    )
-                    .WithArgumentList(
-                        SyntaxFactory.ArgumentList(
-                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
-                                new SyntaxNodeOrToken[]
-                                {
-                                    SyntaxFactory.Argument(rightString),
-                                    SyntaxFactory.Token(
-                                        SyntaxFactory.TriviaList(),
-                                        SyntaxKind.CommaToken,
-                                        SyntaxFactory.TriviaList(
-                                            SyntaxFactory.Space
-                                        )
-                                    ),
-                                    SyntaxFactory.Argument(
-                                        SyntaxFactory.MemberAccessExpression(
-                                            SyntaxKind.SimpleMemberAccessExpression,
-                                            SyntaxFactory.IdentifierName("StringComparison"),
-                                            SyntaxFactory.IdentifierName(type)
-                                        )
-                                    )
-                                }
-                            )
-                        )
-                    );
+            context.RegisterRefactoring(actionIvariantCulture);
+            context.RegisterRefactoring(actionOrdinal);
         }
     }
 }
\ No newline at end of file
diff --git a/CSafeRefactoring/CSafeRefactoring/StartsWithIgnoreCaseRefactoringProvider.cs b/CSafeRefactoring/CSafeRefactoring/StartsWithIgnoreCaseRefactoringProvider.cs
index 961440a..b39cae2 100644
--- a/CSafeRefactoring/CSafeRefactoring/StartsWithIgnoreCaseRefactoringProvider.cs
+++ b/CSafeRefactoring/CSafeRefactoring/StartsWithIgnoreCaseRefactoringProvider.cs
@@ -9,7 +9,9 @@ namespace CSafeRefactoring
     public class StartsWithIgnoreCaseRefactoringProvider : StartsEndsWithRefactoringBase
     {
         protected override string MethodToReplaceName => "StartsWithCSafe";
+
         protected override string NewMethodName => "StartsWith";
+
         protected override bool IgnoreCase => true;
 
         protected override bool AnalyzeAdditionalRestrictions(InvocationExpressionSyntax invocationExpr)
diff --git a/CSafeRefactoring/CSafeRefactoring/StartsWithRefactoringProvider.cs b/CSafeRefactoring/CSafeRefactoring/StartsWithRefactoringProvider.cs
index 0d9f47c..d499ef9 100644
--- a/CSafeRefactoring/CSafeRefactoring/StartsWithRefactoringProvider.cs
+++ b/CSafeRefactoring/CSafeRefactoring/StartsWithRefactoringProvider.cs
@@ -9,6 +9,7 @@ namespace CSafeRefactoring
     public class StartsWithRefactoringProvider : StartsEndsWithRefactoringBase
     {
         protected override string MethodToReplaceName => "StartsWithCSafe";
+
         protected override string NewMethodName => "StartsWith";
 
         protected override bool IgnoreCase => false;
diff --git a/CSafeRefactoring/CSafeRefactoring/Substituters/EqualsSubstituter.cs b/CSafeRefactoring/CSafeRefactoring/Substituters/EqualsSubstituter.cs
new file mode 100644
index 0000000..971bbdd
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/Substituters/EqualsSubstituter.cs
@@ -0,0 +1,56 @@
+using System.Threading;
+using System.Threading.Tasks;
+using CSafeRefactoring.SyntaxTreeCreators;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CSafeRefactoring.Substituters
+{
+    internal class EqualsSubstituter
+    {
+        private Document Document { get; }
+
+        private InvocationExpressionSyntax InvocationExpressionSyntax { get; }
+
+        private bool IgnoreCase { get; }
+
+        public EqualsSubstituter(Document document, InvocationExpressionSyntax invocationExpressionSyntax, bool ignoreCase)
+        {
+            Document = document;
+            InvocationExpressionSyntax = invocationExpressionSyntax;
+            IgnoreCase = ignoreCase;
+        }
+
+        public async Task<Document> FixDocument(string type, CancellationToken cancellationToken)
+        {
+            var root = await Document.GetSyntaxRootAsync(cancellationToken);
+
+            var memberAccessExpressionSyntax = InvocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
+            if (memberAccessExpressionSyntax?.Expression == null)
+            {
+                return Document;
+            }
+
+            var leadingTrivia = memberAccessExpressionSyntax.Expression.GetLeadingTrivia();
+            var leftString = memberAccessExpressionSyntax.Expression.WithoutLeadingTrivia();
+            var rightString = InvocationExpressionSyntax.ArgumentList.Arguments[0].Expression;
+
+            var newSyntaxTree = CreateNewOrdinalSyntaxTree(leftString, rightString, leadingTrivia, type);
+            var newRoot = root.ReplaceNode(InvocationExpressionSyntax, newSyntaxTree);
+            return Document.WithSyntaxRoot(newRoot);
+        }
+
+        private InvocationExpressionSyntax CreateNewOrdinalSyntaxTree(ExpressionSyntax leftString, ExpressionSyntax rightString, SyntaxTriviaList leadingTrivia, string type)
+        {
+            var syntaxTreeCreator = new EqualsSyntaxTreeCreator(leftString, rightString);
+            if (IgnoreCase)
+            {
+                return syntaxTreeCreator.Create($"{type}IgnoreCase")
+                     .WithLeadingTrivia(leadingTrivia);
+            }
+
+            return syntaxTreeCreator.Create(type)
+                .WithLeadingTrivia(leadingTrivia);
+        }
+    }
+}
diff --git a/CSafeRefactoring/CSafeRefactoring/Substituters/StartsWithEndsWithSubstituter.cs b/CSafeRefactoring/CSafeRefactoring/Substituters/StartsWithEndsWithSubstituter.cs
new file mode 100644
index 0000000..3d9ff87
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/Substituters/StartsWithEndsWithSubstituter.cs
@@ -0,0 +1,121 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CSafeRefactoring.Substituters
+{
+    internal class StartsWithEndsWithSubstituter
+    {
+        private Document Document { get; }
+
+        private InvocationExpressionSyntax InvocationExpressionSyntax { get; }
+
+        private bool IgnoreCase { get; }
+
+        private string NewMethodName { get; }
+
+        public StartsWithEndsWithSubstituter(Document document, InvocationExpressionSyntax invocationExpressionSyntax, bool ignoreCase, string newMethodName)
+        {
+            Document = document;
+            InvocationExpressionSyntax = invocationExpressionSyntax;
+            IgnoreCase = ignoreCase;
+            NewMethodName = newMethodName;
+        }
+
+        public async Task<Document> StringComparisonInvariantCulture(CancellationToken cancellationToken)
+        {
+            var root = await Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+            var memberAccessExpressionSyntax = InvocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
+            if (memberAccessExpressionSyntax?.Expression == null)
+            {
+                return Document;
+            }
+
+            var param1 = memberAccessExpressionSyntax.Expression;
+            var argumentList = InvocationExpressionSyntax.ArgumentList;
+            var param2 = argumentList.Arguments[0].Expression;
+
+            SyntaxNode newRoot;
+
+            if (IgnoreCase)
+            {
+                newRoot = root.ReplaceNode(InvocationExpressionSyntax, Create(param1, param2, "InvariantCultureIgnoreCase"));
+            }
+            else
+            {
+                newRoot = root.ReplaceNode(InvocationExpressionSyntax, Create(param1, param2, "InvariantCulture"));
+            }
+
+            return Document.WithSyntaxRoot(newRoot);
+        }
+
+        public async Task<Document> StringComparisonOrdinal(CancellationToken cancellationToken)
+        {
+            var root = await Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+            var memberAccessExpressionSyntax = InvocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
+            if (memberAccessExpressionSyntax == null)
+            {
+                return Document;
+            }
+
+            var param1 = memberAccessExpressionSyntax.Expression;
+            var argumentList = InvocationExpressionSyntax.ArgumentList;
+            var param2 = argumentList.Arguments[0].Expression;
+
+            SyntaxNode newRoot;
+
+            if (IgnoreCase)
+            {
+                newRoot = root.ReplaceNode(InvocationExpressionSyntax, Create(param1, param2, "OrdinalIgnoreCase"));
+            }
+            else
+            {
+                newRoot = root.ReplaceNode(InvocationExpressionSyntax, Create(param1, param2, "Ordinal"));
+            }
+
+            return Document.WithSyntaxRoot(newRoot);
+
+        }
+
+        private InvocationExpressionSyntax Create(ExpressionSyntax leftString, ExpressionSyntax rightString, string type)
+        {
+            return
+                SyntaxFactory.InvocationExpression(
+                        SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            leftString,
+                            SyntaxFactory.IdentifierName(NewMethodName)
+                        )
+                    )
+                    .WithArgumentList(
+                        SyntaxFactory.ArgumentList(
+                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
+                                new SyntaxNodeOrToken[]
+                                {
+                                    SyntaxFactory.Argument(rightString),
+                                    SyntaxFactory.Token(
+                                        SyntaxFactory.TriviaList(),
+                                        SyntaxKind.CommaToken,
+                                        SyntaxFactory.TriviaList(
+                                            SyntaxFactory.Space
+                                        )
+                                    ),
+                                    SyntaxFactory.Argument(
+                                        SyntaxFactory.MemberAccessExpression(
+                                            SyntaxKind.SimpleMemberAccessExpression,
+                                            SyntaxFactory.IdentifierName("StringComparison"),
+                                            SyntaxFactory.IdentifierName(type)
+                                        )
+                                    )
+                                }
+                            )
+                        )
+                    );
+        }
+
+    }
+}
diff --git a/CSafeRefactoring/CSafeRefactoring/Substituters/ToLowerSubstituter.cs b/CSafeRefactoring/CSafeRefactoring/Substituters/ToLowerSubstituter.cs
new file mode 100644
index 0000000..67d9803
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/Substituters/ToLowerSubstituter.cs
@@ -0,0 +1,44 @@
+using System.Threading;
+using System.Threading.Tasks;
+using CSafeRefactoring.SyntaxTreeCreators;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CSafeRefactoring.Substituters
+{
+    internal class ToLowerSubstituter
+    {
+        private Document Document { get; }
+
+        private InvocationExpressionSyntax InvocationExpressionSyntax { get; }
+
+        public ToLowerSubstituter(Document document, InvocationExpressionSyntax invocationExpressionSyntax)
+        {
+            Document = document;
+            InvocationExpressionSyntax = invocationExpressionSyntax;
+        }
+
+        public async Task<Document> Replace(CancellationToken cancellationToken)
+        {
+            var root = await Document.GetSyntaxRootAsync(cancellationToken);
+
+            var memberAccessExpressionSyntax = InvocationExpressionSyntax.Expression as MemberAccessExpressionSyntax;
+            if (memberAccessExpressionSyntax?.Expression == null)
+            {
+                return Document;
+            }
+
+            var leadingTrivia = memberAccessExpressionSyntax.Expression.GetLeadingTrivia();
+            var identifier = memberAccessExpressionSyntax.Expression.WithoutLeadingTrivia();
+
+            var creator = new ToLowerSyntaxTreeCreator(identifier);
+
+            var newSyntaxTree = creator.Create()
+                .WithLeadingTrivia(leadingTrivia);
+
+            var newRoot = root.ReplaceNode(InvocationExpressionSyntax, newSyntaxTree);
+
+            return Document.WithSyntaxRoot(newRoot);
+        }
+    }
+}
diff --git a/CSafeRefactoring/CSafeRefactoring/SyntaxTreeCreators/ToLowerSyntaxTreeCreator.cs b/CSafeRefactoring/CSafeRefactoring/SyntaxTreeCreators/ToLowerSyntaxTreeCreator.cs
new file mode 100644
index 0000000..0894d43
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/SyntaxTreeCreators/ToLowerSyntaxTreeCreator.cs
@@ -0,0 +1,32 @@
+using System;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CSafeRefactoring.SyntaxTreeCreators
+{
+    public class ToLowerSyntaxTreeCreator
+    {
+        private string IdentifierName { get; }
+
+        public ToLowerSyntaxTreeCreator(ExpressionSyntax identifierName)
+        {
+            if (identifierName == null)
+            {
+                throw new ArgumentNullException(nameof(identifierName));
+            }
+
+            IdentifierName = identifierName.GetText().ToString();
+        }
+
+        public InvocationExpressionSyntax Create()
+        {
+            return SyntaxFactory.InvocationExpression(
+                SyntaxFactory.MemberAccessExpression(
+                    SyntaxKind.SimpleMemberAccessExpression,
+                    SyntaxFactory.IdentifierName(IdentifierName),
+                    SyntaxFactory.IdentifierName("ToLowerInvariant")
+                )
+            );
+        }
+    }
+}
diff --git a/CSafeRefactoring/CSafeRefactoring/ToLowerrefactoringProvider.cs b/CSafeRefactoring/CSafeRefactoring/ToLowerrefactoringProvider.cs
new file mode 100644
index 0000000..69f34ef
--- /dev/null
+++ b/CSafeRefactoring/CSafeRefactoring/ToLowerrefactoringProvider.cs
@@ -0,0 +1,53 @@
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using CSafeRefactoring.Substituters;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace CSafeRefactoring
+{
+    [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = nameof(ToLowerRefactoringProvider)), Shared]
+    public class ToLowerRefactoringProvider : CodeRefactoringProviderBase
+    {
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
+        {
+            var root = await context.Document
+                 .GetSyntaxRootAsync(context.CancellationToken)
+                 .ConfigureAwait(false);
+
+            var node = root.FindNode(context.Span);
+
+            if (!IsCurrentNodeReplacedMethod(node))
+            {
+                return;
+            }
+
+            var declaration = root
+                .FindNode(context.Span)
+                .Parent
+                .AncestorsAndSelf()
+                .OfType<InvocationExpressionSyntax>()
+                .First();
+
+            CreateAndRegisterCodeActions(context, declaration);
+        }
+
+
+        private void CreateAndRegisterCodeActions(CodeRefactoringContext context, InvocationExpressionSyntax declaration)
+        {
+
+         var substituter = new ToLowerSubstituter(context.Document, declaration);
+            var actionIvariantCulture = CodeAction.Create("Use ToLowerInvariant",
+                cancellationToken => substituter.Replace(cancellationToken));
+
+            context.RegisterRefactoring(actionIvariantCulture);
+        }
+
+        protected override string MethodToReplaceName => "ToLowerCSafe";
+
+        protected override bool IgnoreCase => false;
+    }
+}
diff --git a/Tests/Base/CodeRefactoringTestFixture.cs b/Tests/Base/CodeRefactoringTestFixture.cs
index 4bd0a90..1da2074 100644
--- a/Tests/Base/CodeRefactoringTestFixture.cs
+++ b/Tests/Base/CodeRefactoringTestFixture.cs
@@ -18,11 +18,12 @@ public abstract class CodeRefactoringTestFixture : BaseTestFixture
         private static readonly MetadataReference C_SHARP_SYMBOLS_REFERENCE = MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location);
         private static readonly MetadataReference CODE_ANALYSIS_REFERENCE = MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location);
 
-
         internal static string DefaultFilePathPrefix = "Test";
         internal static string CSharpDefaultFileExt = "cs";
         internal static string TestProjectName = "TestProject";
 
+        protected override string LanguageName => LanguageNames.CSharp;
+
         protected abstract CodeRefactoringProvider CreateProvider();
 
         protected void TestCodeRefactoring(string markupCode, params string[] expected)
diff --git a/Tests/EndsWithIgnoreCaseUnitTests.cs b/Tests/EndsWithIgnoreCaseUnitTests.cs
index a0e6349..72f07ee 100644
--- a/Tests/EndsWithIgnoreCaseUnitTests.cs
+++ b/Tests/EndsWithIgnoreCaseUnitTests.cs
@@ -181,8 +181,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new EndsWithIgnoreCaseRefactoringProvider();
diff --git a/Tests/EndsWithUnitTests.cs b/Tests/EndsWithUnitTests.cs
index 67bd481..24b36df 100644
--- a/Tests/EndsWithUnitTests.cs
+++ b/Tests/EndsWithUnitTests.cs
@@ -181,8 +181,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new EndsWithRefactoringProvider();
diff --git a/Tests/EqualsIgnoreCaseUnitTests.cs b/Tests/EqualsIgnoreCaseUnitTests.cs
index 375cfd8..29937bf 100644
--- a/Tests/EqualsIgnoreCaseUnitTests.cs
+++ b/Tests/EqualsIgnoreCaseUnitTests.cs
@@ -49,8 +49,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new EqualsIgnoreCaseRefactoringProvider();
diff --git a/Tests/EqualsUnitTests.cs b/Tests/EqualsUnitTests.cs
index 220a99c..f5a12f3 100644
--- a/Tests/EqualsUnitTests.cs
+++ b/Tests/EqualsUnitTests.cs
@@ -122,8 +122,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new EqualsRefactoringProvider();
diff --git a/Tests/Properties/AssemblyInfo.cs b/Tests/Properties/AssemblyInfo.cs
index b77f7ee..f9f1eee 100644
--- a/Tests/Properties/AssemblyInfo.cs
+++ b/Tests/Properties/AssemblyInfo.cs
@@ -1,5 +1,4 @@
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 // General Information about an assembly is controlled through the following 
diff --git a/Tests/StartsWithIgnoreCaseUnitTests.cs b/Tests/StartsWithIgnoreCaseUnitTests.cs
index dba2922..165df40 100644
--- a/Tests/StartsWithIgnoreCaseUnitTests.cs
+++ b/Tests/StartsWithIgnoreCaseUnitTests.cs
@@ -181,8 +181,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new StartsWithIgnoreCaseRefactoringProvider();
diff --git a/Tests/StartsWithUnitTests.cs b/Tests/StartsWithUnitTests.cs
index 449f5a6..7b54422 100644
--- a/Tests/StartsWithUnitTests.cs
+++ b/Tests/StartsWithUnitTests.cs
@@ -181,8 +181,6 @@ public void method()
             TestCodeRefactoring(markupCode, expected, expected2);
         }
 
-        protected override string LanguageName => Microsoft.CodeAnalysis.LanguageNames.CSharp;
-
         protected override CodeRefactoringProvider CreateProvider()
         {
             return new StartsWithRefactoringProvider();
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index 0725b5e..f7f796d 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -123,6 +123,7 @@
     <Compile Include="EqualsUnitTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Base\Verify.cs" />
+    <Compile Include="ToLowerUnitTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
diff --git a/Tests/ToLowerUnitTests.cs b/Tests/ToLowerUnitTests.cs
new file mode 100644
index 0000000..6c2f0f1
--- /dev/null
+++ b/Tests/ToLowerUnitTests.cs
@@ -0,0 +1,99 @@
+using CSafeRefactoring;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using NUnit.Framework;
+using CodeRefactoringTestFixture = Tests.Base.CodeRefactoringTestFixture;
+
+namespace Tests
+{
+    [TestFixture]
+    public class ToLowerUnitTests : CodeRefactoringTestFixture
+    {
+
+        [Test]
+        public void Identifiers()
+        {
+            const string markupCode = @"
+public class Ex 
+{
+    public void method()
+    {
+        str.[|ToLowerCSafe|]();
+    }
+}
+";
+
+            const string expected = @"
+public class Ex 
+{
+    public void method()
+    {
+        str.ToLowerInvariant();
+    }
+}
+";
+
+
+            TestCodeRefactoring(markupCode, expected);
+        }
+
+
+        [Test]
+        public void StringLiteral()
+        {
+            const string markupCode = @"
+public class Ex 
+{
+    public void method()
+    {
+        ""str"".[|ToLowerCSafe|]();
+    }
+}
+";
+
+            const string expected = @"
+public class Ex 
+{
+    public void method()
+    {
+        ""str"".ToLowerInvariant();
+    }
+}
+";
+
+
+            TestCodeRefactoring(markupCode, expected);
+        }
+
+
+        
+
+        [Test]
+        public void ExpresionInSecondParameter()
+        {
+            const string markupCode = @"
+public class Ex 
+{
+    public void method()
+    {
+        (""text"" + str).[|ToLowerCSafe|]();
+    }
+}
+";
+
+            const string expected = @"
+public class Ex 
+{
+    public void method()
+    {
+        (""text"" + str).ToLowerInvariant();
+    }
+}
+";
+            TestCodeRefactoring(markupCode, expected);
+        }
+        protected override CodeRefactoringProvider CreateProvider()
+        {
+            return new ToLowerRefactoringProvider();
+        }
+    }
+}