# Update in .NET Core 2.0+ (August 2017)

This is natively available in .NET Core 2.0<sup>+</sup> with [`String.Replace`][1] which has the following overloads

```cs
public string Replace (string oldValue, string newValue, StringComparison comparisonType);
public string Replace (string oldValue, string newValue, bool ignoreCase, System.Globalization.CultureInfo culture);
```


So you can use either like this:

```cs
"A".Replace("a", "b", StringComparison.CurrentCultureIgnoreCase);
"A".Replace("a", "b", true, CultureInfo.CurrentCulture);
```


> **PS**: You can [browse .NET Core source][6] if you want to see how MS implemented it

----

### Legacy .NET Framework 4.8<sup>-</sup> option for VB Projects

Visual Basic has an [**`Option Compare`**][2] setting which can be set to `Binary` or `Text`

Setting to `Text` will make all string comparisons across your project case insensitive by default.

So, as other answers have suggested, if you are pulling in the `Microsoft.VisualBasic.dll`, when calling [`Strings.Replace`][3] if you don't explicitly pass a [`CompareMethod`][4] the method will [actually defer to the `Compare` option for your file or project][5] using the `[OptionCompare]` Parameter Attribute

So either of the following will also work (*top option only available in VB , but both rely on VisualBasic.dll*) 

```vb
Option Compare Text

Replace("A","a","b")
```

```vb
Replace("A","a","b", Compare := CompareMethod.Text)
```


[1]: https://learn.microsoft.com/en-us/dotnet/api/system.string.replace?view=netcore-2.0#System_String_Replace_System_String_System_String_System_StringComparison_
[2]: https://learn.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/option-compare-statement
[3]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.strings.replace?view=netframework-4.8
[4]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.comparemethod?view=netframework-4.8
[5]: https://referencesource.microsoft.com/#Microsoft.VisualBasic/Microsoft/VisualBasic/Strings.cs,61
[6]: https://source.dot.net/#System.Private.CoreLib/String.Manipulation.cs,998

I recently had to perform some string replacements in .net and found myself developing a regular expression replacement function for this purpose. After getting it to work I couldn't help but think there must be a built in case insensitive replacement operation in .Net that I'm missing?

Surely when there are so many other string operations that support case insensitive comparission such as;

    var compareStrings  = String.Compare("a", "b", blIgnoreCase);
    var equalStrings    = String.Equals("a", "b", StringComparison.CurrentCultureIgnoreCase);

then there must be a built in equivalent for replace?

Is there a case insensitive string replace in .Net without using Regex?

You can change the VS search result formatting by changing the registry.

According to the article [Customize how Find in Files results are displayed in the Find Results Window][1]:

> 1. Open up RegEdit
2. Go to `HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\Find`
3. Add a new string called `Find result format` with a value of `$f$e($l,$c):$t\r\n`

> **DANGER**:  This involves hacking the Registry so use this tip at your own risk!

Further, here's the syntax to use if you'd like to customize the string further:

**Files**

* `$p` - path                       
* `$f` - filename               
* `$v` - drive/unc share            
* `$d` - dir                        
* `$n` - name                       
* `$e` - .ext                   
    

**Location**

* `$l` - line                        
* `$c` - col                        
* `$x` - end col if on first line, else end of first line
* `$L` - span end line
* `$C` - span end col

**Text**

* `$0` - matched text                
* `$t` - text of first line
* `$s` - summary of hit
* `$T` - text of spanned lines

**Char**

* `\n` - newline                   
* `\s` - space                     
* `\t` - tab                        
* `\\` - slash                    
* `\$` - $    
     

  [1]: http://blogs.msdn.com/b/zainnab/archive/2010/01/03/customize-how-search-results-are-displayed-in-the-find-results-window.aspx

Because of all the sub-directories my code typically lives in, whenever I do a Find In File for something, the code gets run off the screen because the results window has wasted so much valuable real estate by repeating the long file path for every object in my solution.  More often than not, they are in the same parent directory, or I don't really care where there from.  

*Is there an option to shorten the path name to perhaps just the file?*

![Unnecessarily long][1]


Also, the `Display File Names Only` option in the `Find in Files` dialog does not do this, it only omits the code from the result.

![Find in Files Dialog][2]


  [1]: http://i.imgur.com/sDWkriQ.png
  [2]: http://i.stack.imgur.com/7Avsb.png

Shorten Find Results Filepath Name

This does it:

    ;WITH versions (suffix) AS (
        SELECT '_R1' UNION ALL
        SELECT '_v2' UNION ALL
        SELECT '_v1'
    )
    SELECT	name, 
    		REPLACE(A.name,ISNULL(B.suffix,''),'') VersionlessName
    FROM applications A
    LEFT JOIN versions B
    	ON A.name LIKE '%'+B.suffix

The results are:

    ╔════════════╦═════════════════╗
    ║    name    ║ VersionlessName ║
    ╠════════════╬═════════════════╣
    ║ MyApp_v2   ║ MyApp           ║
    ║ MyApp_v1   ║ MyApp           ║
    ║ MyApp      ║ MyApp           ║
    ║ YourApp_R1 ║ YourApp         ║
    ╚════════════╩═════════════════╝
And [**here is**][1] the modified sqlfiddle.


  [1]: http://sqlfiddle.com/#!3/400cb/1

I'm trying to strip off version suffixes (`_v1`...) from a whole bunch of app names. 

For example, let's say I have the following data:

    CREATE TABLE applications 
     (
       name varchar(20)
     );
    
    INSERT INTO applications
     (name)
    VALUES
     ('MyApp_v2'),
     ('MyApp_v1'),
     ('MyApp'),
     ('YourApp_R1');

I could normally do this by nesting a lot of replace statements:

    SELECT REPLACE(REPLACE(REPLACE(
             name,
           '_R1', ''),
           '_v2', ''),
           '_v1', '')
           As AppNameWithoutSuffix
    FROM applications

But I have a lot of version numbers to check for, so I was hoping for something cleaner.  Based on the following questions:

* [SQL Nested Replace][SO1]
* [Are multiple Replace statements a bad practice/is there another way to write them?][SO2]



I wanted to create a CTE that stored all the prefixes and then [`REPLACE`][Replace] them all like this:

    ;WITH versions (suffix) AS (
        SELECT '_R1' UNION ALL
        SELECT '_v2' UNION ALL
        SELECT '_v1'
    )
    SELECT REPLACE(a.name, v.suffix, '') As AppNameWithoutSuffix
    FROM applications a,
         versions v

But this does not quite work.  The multiple from statements gives me the cartesian product of both tables and only strips out the suffix on the rows where the value happens to line up.

### [Demo in Sql Fiddle][Sql Fiddle]

*Note*: I know I could convert this to a function, but I'd rather keep everything within a single query if possible.  

[SO1]: https://stackoverflow.com/q/13088921/1366033
[SO2]: https://stackoverflow.com/q/5475428/1366033
[Sql Fiddle]: http://sqlfiddle.com/#!18/165bb/3

[Replace]: http://msdn.microsoft.com/en-us/library/ms186862.aspx