How to include multiple source files in C#

You pass the list of source files to the compiler:

csc.exe /target:library source1.cs source2.cs

If you use Visual Studio when you create a new .NET project you can add as many source files as you like and they will automatically be compiled.

If you are building this in Visual Studio, then simply having the 2 files in the same project is all you need to do.

If you are compiling on the command line using csc you ned to reference both files in the call to csc. See Darin's response for this.

There is no need to reference one file from the other, but the easiest way to make types to be visibile to each other would be to add the classes in each file to the same namespace.

I am also new to C#. I found this thread while looking for an answer on how to include multiple source files when compiling C# from the command-line. But the current answers are incomplete in my opinion. Here is something that would have made sense to me this morning:

hello.cs

using System;

namespace PartialClasses
{
    class Program
    {
    static void Main(string[] args)
    {
        PartialClass pc = new PartialClass();
        pc.HelloWorld();
        pc.HelloUniverse();
    }
    }
}

PartialClass1.cs

using System; 

namespace PartialClasses
{
    public partial class PartialClass
    {
        public void HelloWorld()
        {
            Console.WriteLine("Hello, world!");
        }
    }
}

PartialClass2.cs

using System;

namespace PartialClasses
{
    public partial class PartialClass
    {
    public void HelloUniverse()
    {
        Console.WriteLine("Hello, universe!");
    }
    }
}

I am using Mono to compile my source file(s). And, so far, nothing I've come across informs what I need to do.

After some digging, I found the following syntax.

First, I want to create a library of my partial classes.

csc -target:library -out:myLibrary.dll Partial*.cs

Then I want to reference that library I just made when compiling my main program. I was fortunate to find an example demonstrating the syntax I needed.

csc -reference:.\myLibrary.dll hello.cs

That is what worked for me.

mono .\hello.exe
Hello, world!
Hello, universe!

With respect to the #include directive, it is not needed in C#. And I refer the reader to Dan Bryant's comment above. Instead, keep your class names and namespaces straight and tell the compiler where to find the library (that you created). That is how the connection between source files is made in C#.

There is also MSBuild for .csproj files and more complicated projects. But, as a beginner, that is beyond my ability to explain.

Credit goes to The Complete C# Tutorial for providing the code I used.

For reference, the compiler error I was getting for csc hello.cs was CS0246. That Microsoft article helped a little. So did -reference (C# Compiler Options).

The source files don't need to know about each other. The options are:

• Compile both files together, as per Darin's answer
• Compile one file into a class library, and add a reference to that library when compiling the other

It depends on whether you want the result to be one assembly or two. Usually the answer would be to compile the two together into the same assembly though.

If you like to split your class to two (or more) source files, you can use partial class definitions. So in your case, you have "class TheClass" in the main.cs and "partial class TheClass" in the test.cs. This is not same as #include, but I guess close enough.

I often use the command

csc *.cs

It attempts to compile all the .cs files in the current directory. I find it the simplest and most generally useful way for these kind of command line compilations, like for javas

javac *.java

Additionally you dont have to worry about the file that Main() resides, it automatically detects the entry point.

it took me way too long to go from nothing, to a working example of linking two csharp files together, so, for my own clarity, here are two working examples in mono:

How to merge multiple csharp source files into one exe/dll

• let us have two csharp files: bar.cs and foo.cs
• let us want to call foo functions from bar functions.

.
├── bar.cs
├── foo.cs
└── Makefile

0 directories, 3 files

• let our foo symbol be a simple x squared function

// foo.cs
public static class foo {
    public static int square(int x) {
        return x * x;
    }
}

• let our bar have a simple call to this square function
• let bar handle the program main entry point adapter, including conventional c99 int main(int argc, char** argv) {}; io for clarity

// bar.cs
public static class bar {
    public static int three_square() {
        return foo.square(3);
    }

    public static int main(int argc, string[] argv) {
        System.Console.WriteLine("Hello World");
        string prog = argv[0];
        System.Console.WriteLine(System.String.Format("program is '{0}'", prog));
        for (int argi = 1; argi < argc; argi++) {
            System.Console.WriteLine(System.String.Format("got argument '{0}'", argv[argi]));
        }
        System.Console.WriteLine(System.String.Format("three_squared is '{0}'", three_square()));
        return 0;
    }

    public static int Main() {
        string[] argv = System.Environment.GetCommandLineArgs();
        int argc = argv.Length;
        return main(argc, argv);
    }
}

As shown in this example, there is no reference from bar.cs to foo.cs at all. The relationship is established at compile-time by including the foo.cs code within the bar.cs compilation unit. Here I accomplish this with a basic Makefile

# Makefile
all: myprog.exe mylib.dll
myprog.exe: foo.cs bar.cs
→   mono-csc $^ -out:$@
mylib.dll: foo.cs bar.cs
→   mono-csc -target:library $^ -out:$@

This Makefile is equivalent to executing the bash command literal:

$ mono-csc foo.cs bar.cs -out:myprog.exe
$ mono-csc -target:library foo.cs bar.cs -out:mylib.dll

result

├── bar.cs
├── foo.cs
├── Makefile
├── mylib.dll
└── myprog.exe

0 directories, 5 files

running the program

$ ./myprog.exe 
Hello World
program is '/opt/demo/myprog.exe'
three_squared is '9'

How to dynamically link multiple csharp source files as separate exe/dll files

(I found the csharp behavior extremely un-intuitive ^[2] here.)

• let us have two csharp files: baz.cs and faz.cs
• let us want to call faz functions from baz functions.

.
├── baz.cs
├── faz.cs
└── Makefile

0 directories, 5 files

// faz.cs
public static class faz {
    public static int square(int x) {
        return x*x;
    }
}

// baz.cs
public static class baz {
    public static int main(int argc, string[] argv) {
        System.Console.WriteLine("Hello World");
        string prog = argv[0];
        System.Console.WriteLine(System.String.Format("program is '{0}'", prog));
        for (int argi = 1; argi < argc; argi++) {
            System.Console.WriteLine(System.String.Format("got argument '{0}'", argv[argi]));
        }
        System.Console.WriteLine(System.String.Format("four squared from 'faz' is '{0}'", faz.square(4)));
        return 0;
    }

    public static int Main() {
        string[] argv = System.Environment.GetCommandLineArgs();
        int argc = argv.Length;
        return main(argc, argv);
    }
}

As shown in this example, there is no reference from baz.cs to faz.cs at all. faz is just an anonymous name in baz.cs. The relationship is established at compile-time by including a reference assembly mylib.dll, presumably csharp will read some csharp specific index of all symbols within all referenced assemblies and decide to map our public static class faz to the name faz in baz.cs for us ^[1]. Here I accomplish this linkage with a basic Makefile:

# Makefile
all: myprog2.exe
faz.dll: faz.cs
    mono-csc -target:library $^ -out:$@
myprog2.exe: faz.dll baz.cs
    mono-csc baz.cs -r:faz.dll -out:$@

This Makefile is equivalent to executing the bash command literal:

$ mono-csc -target:library faz.cs -out:faz.dll
$ mono-csc baz.cs -r:faz.dll -out:myprog2.exe

result

├── baz.cs
├── faz.cs
├── faz.dll
├── Makefile
└── myprog2

0 directories, 5 files

running the program

$ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="asm,dll" mono ./myprog2.exe
Mono: ...
Mono: Loading reference 0 of /opt/demo2/faz.dll asmctx DEFAULT, looking for mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
Mono: ...

Hello World
program is '/opt/demo2/myprog2.exe'
four squared from 'faz' is '16'

_footnotes

• [1] I'm not sure how to gain any firm grantees here.Note, if you try to compile mono-csc with two dll's eg -r:./my.dll -r:./myevil.dll and they both declare public static class faz {...}, csc will abort with error CS0433: The imported type 'faz' is defined multiple times.
• [2] trying to access mylib.dll as a conventional dll doesn't work. eg public static class libfaz {[System.Runtime.InteropServices.DllImport("libfaz.dll")] public static extern int square(int x);} compiles, but fails to execute. (Troubleshoot with MONO_LOG_LEVEL="debug" MONO_LOG_MASK="asm,dll" mono ./myprog2.exe to note that dlopen fails once it finces mylib.dll due to bin format issue). I expect this cannot resolve either due to dlopen() bin format incompatibility or because of some dlsym() name mangling incompatibility. csharp is magic and invisible instead.

You don't need to link source file in c#/dotnet. All .cs file included in .csproject will automatically gathered. what you need to do is make sure all .cs file in same namespace,then using namespace.

Helper.cs

namespace YourProject.Helper
{
    // codes 
}

Program.cs

using YourProject.Helper
namespace YourProject.Program
{
        // codes 
}

There is no equivalent to including files in C#, so all you have to do boils down to compiling.

Here is an example of two C# files in one folder which get compiled to one executable on Windows.

hello.sc:

using System;
using Test;

public class MyProgram {
    public static void Main() {
        var name = Util.Name();
        Console.WriteLine($"Hello {name}!");
    }

}

world.cs

namespace Test {
    public class Util {
        public static string Name() {
            return "world";
        }
    }
}

Open command prompt in the containing folder and compile with csc by:^[1]

csc /out:hello.exe *.cs

Now you can start the executable hello.exe in the same folder.

^[1] If the csc command wasn't made available by other means, you can do the following.

Locate the file csc.exe. For example, in Visual Studio 2022 Community Edition, it can be found in:

C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\Roslyn\

For convenience, you may create a csc.cmd tool in a folder that's included in the system %path%:

"C:\Program Files\Microsoft Visual Studio\2022\Community\MSBuild\Current\Bin\Roslyn\csc.exe" %*