This extension provides a context menu button to add a new class, which will auto populate the namespace.

Visual Studio Code has changed a bit since the last answer. It now provides the variable TM_DIRECTORY in snippets, but this is an absolute path. I've submitted an enhancement request to provide a relative path that could be transformed to a namespace. But honestly, I think the above extension satisfies my needs (and the context menu is a plus)

I have found these extensions that provide create C# class context menu option:

• VS Sharper for C#
• C# helper
• C# Template Extensions
• HelloVS - C# new file

A moderately dirty solution with the current variable and regex system of vscode is the following:

Assuming that your have all your projects in /your/projects/directory/

So project #1 is in /your/projects/directory/Project1/
And project #2 is in /your/projects/directory/Project2/
etc.

The following snippet will create a namespace implementation for all sub-directories:

Linux/ MacOS

"Namespace declaration":
{
    "prefix": "name",
    "description": "Creates a new namespace declaration.",
    "body":
    [
        "namespace ${TM_DIRECTORY/^\\/your\\/projects\\/directory(\\/([^\\/]+))(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?(\\/([^\\/]+))?/$2${3:+.}$4${5:+.}$6${7:+.}$8${9:+.}$10${11:+.}$12${13:+.}$14${15:+.}$16${17:+.}$18${19:+.}$20/gi}",
        "{",
        "}"
    ]
}

Windows

"Namespace declaration":
{
    "prefix": "name",
    "description": "Creates a new namespace declaration.",
    "body":
    [
        "namespace ${TM_DIRECTORY/^c:\\\\your\\\\projects\\\\directory(\\\\([^\\\\]+))(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?(\\\\([^\\\\]+))?/$2${3:+.}$4${5:+.}$6${7:+.}$8${9:+.}$10${11:+.}$12${13:+.}$14${15:+.}$16${17:+.}$18${19:+.}$20/gi}",
        "{",
        "}"
    ]
}

Explanation

1. The snippet matches your base directory and up to ten sub-directories (the first directory is mandatory (\\/([^\\/]+)), while all additional nine ones are optional (\\/([^\\/]+))?)
2. The namespace directive is then created with the first matched directory
3. For every successful additional sub-directory match, a dot . is inserted (${3:+.}) with the sub-match of that group ($4); for unsuccessful groups, no dot inserted and the sub-match is empty

Enjoy :)

Found this thread looking for the same answer.

I did not find any of the existing snippet suggestions to generate proper namespaces.
After some trial and error the closest I have gotten, using "variables" and "placeholder transformation", is:

    "Namespace and Class": {
        "prefix": "nclass",
        "body": [
            "namespace ${RELATIVE_FILEPATH/[\\\\]|\\w+\\.cs$/./g}$1",
            "{",
            "\tpublic class $TM_FILENAME_BASE\n\t{\n\t\t$0\n\t}",
            "}"
        ],
        "description": "Generates namespace and class name"
    }

This will generate a namespace from the folder structure in the workspace, and class name using the file name.

There is however an issue with this as it will leave two trailing .. at end of namespace. But cursor will stop there, so they can quickly be removed with a Ctrl + Backspace and then tab again to jump inside body of the class.

Use this one, first it focuses at the end of the namespace to add any additional section. Then it focuses inside the class.

"Namespace and Class": {
    "prefix": "nc",
    "body": [
        "namespace $WORKSPACE_NAME$1\n{\n\tpublic class $TM_FILENAME_BASE\n\t{\n\t\t$2\n\t}\n}"
    ],
    "description": "Generates namespace and class name"
}

Well, i was strugling with that too, but with all of the responses in this post i was able find the following solution:

"namespace ${RELATIVE_FILEPATH/(\\\\([^\\\\]+)$)|(\\\\)/${3:+.}/g} ;",

This will replace every backslash with a dot and remove the filename. Example: MyFolder\\SubFolder\\MyFile.cs will generate MyFolder.SubFolder

My Full Snippet File:

{
    "Default C# Class": {
    "prefix": "csclassstart",
    "isFileTemplate": true,
    "body": [
        "using System;",
        "",
        "namespace ${RELATIVE_FILEPATH/(\\\\([^\\\\]+)$)|(\\\\)/${3:+.}/g} ;",
        "",
        "public class ${TM_FILENAME_BASE} {",
        "    $0",
        "    public ${TM_FILENAME_BASE}(){",
        "    }",
        "}",
        ""
    ],
    "description": "C# class with dynamic class name and namespace derived from file name directories"
    }
}

How this works

Our goals are the following: (1) Remove the \\filename.cs from the RELATIVE_FILEPATH variable; (2) replace the double-backslashes (\\) with dots (.)

First we capture the filename by capturing everithing that matches the following:

• double-backslashes \\\\
• followed by something that isnt a backslash ([^\\\\]+)
• followed by the end of the string $

This generates two capture groups

they are: (\\\\([^\\\\]+)$) and ([^\\\\]+) (the second is inside the first)

but we dont realy care about them, we just neet to keep count.

Then we use a OR | to capture a third group, witch is composed exclusively of double-backslashes (\\\\).

Finaly, we replace all captured groups with the following: ${3:+.} witch basically means,

if capture-group 3 is not empty, replace it with a dot (.).

With that, all double-backslashes will be replaced by dots, except the ones in \\filename.cs.

Thats happens because of the OR operator (|), witch will make this sequence will match the first capture-group and skip the third, making it empty and not triggering the replacement.

Because of that, is important to note that the order of the capture-groups is very important for this to wwork