Introduction and Background
In the previous posts for the series, I talked about the IDE itself, I talked about the tools provided in the MonoDevelop and the Mono Project for C# developers that would help them do their jobs quickly. You may want to read those posts first and then continue to read this post, or the other way as I have tried to abstract the posts enough.
- Guide for building C# apps on Ubuntu: MonoProject Introduction
- Guide for building C# apps on Ubuntu: Language quickies
Later, you can continue to read this post. This post has a primary focus on the project files, compiled assemblies and the executable files generated after the build process. So, although this would be a very short guide, I would try to explain every aspect of it. You can however let me know if you find something missing here.
I assume that you already have an idea of C# project files, typically they are:
- One solution file (.sln)
- A folder for the project itself
- Properties files
- Binary and object files folder
You will find this template for a project of C# everywhere, from Console to any graphical application that you may be using. The template is chosen to make sure you can always skim through the file system and find the required item there. So now let’s talk about these items in detail…
Project Files and Output Locations
If you have ever programmed in C# on Windows, using Visual Studio you may know the common folders and locations for the project and the generated binaries. For each of the projects that you create, Visual Studio creates quite a similar project directory and puts the source code, project settings files, and others in that directory.
MonoDevelop does the same for you! MonoDevelop would ask for a location to create the directory for the project and would then use that location to create new files, and to place the compiled executables. We are going to talk about a few of these locations and the files generated there.
1. Project Directory Itself…
First of all, let us talk about the project directory that gets created. This location is chosen by you, you are given full permissions to chose a location to select the directory at. You can enter the location and then MonoProject would use the same location to perform the actions, like creating and adding new files, resources and source files, also the same location is used to generate and place the binaries and object code files. So, this directory is used throughout the project life, choose it wisely.
So, for example, when we created the project (in the previous sections), we entered the following location to be selected as the project directory.
Figure 1: Creating the project and entering the location for the project directory.
Have a look at the “
Location” field in the above window. We can change it from here, we can also browse for a new location and well, you get the idea that we can create the directory anywhere that we find it helpful and easy to be found!
Remember: Projects is also a manual location in Ubuntu, by default the home folder for users do not contain a folder named Projects.
Once we create the project, the files are generated at that location and the project window opens. However, we are only interested in viewing the directory itself and not the project code. The files that are generated here, are very much similar to Visual Studio’s files, it also contains the solution file. Solution files typically hold the information for the project, files and other settings and configurations that you make in the project; like architecture support. Only these files are provided along with the templates because IDEs use a special project file to determine the configuration and the files for the project.
By default, the directory has 1 sub-directory and 2 files:
Figure 1: Root level of the project, one folder and solution and preferences files in the directory.
As already discussed, the directory is used to hold the files and references for the projects and also holds the generated binaries and executable files. However, before diving any deeper, let us talk about the files that we can see right here. These files contain the settings for the project and for the user sessions.
First of all, let us talk about the solution file itself. The solution file is basically the settings and overall configurations that you make to the project itself. The project is what you create when you start Mono and go ahead creating something. Things that you create in a project are files, resources and source code files, etc.
We can open the file up in the text editor, the code in this file is simply commands and settings that would train the environment to set up the configuration for build and a few others, like the name of the project (obviously!)
This file contains the information about:
- Project itself
- Package identifier. Sometimes a GUID
- Build configurations
- They are written in the global scope for the environment
- Active build configurations for debug and release mode
- Extra configurations
- CPU architectures used
- Project details file name and other minimal files used for project management
So, this file is created and is maintained throughout the project. You can also start the project by double-clicking the file for C# project in the same directory (make sure you do not open it in text editor itself). For more on Solution files, please refer to MSDN, as they describe the file in a much better way: Solution (.Sln) File.
Ever wondered how your IDE knows where to start and which line you were previously working on? This file holds the information for that, this file holds the information for currently active file, currently active line and even the column where your cursor was!
So, basically this file holds the information for your currently active session and when you reload the IDE and the same project, your IDE would know where to get you started from. This saves a lot of time of developers as the source code file and the line is already active, they can just continue to work from where they left it.
This file also keeps a hold of your breakpoints. So, everything and every change that you make in the files (not the project!) is saved here. This file is checked against when a new instance is starting so that your sessions are started without any trouble.
This ends here. I think the purpose of these files is pretty much clear. The next step is to go inside the folder and look there… Next I will simply just talk about the files, and the output folders where you would find your assemblies being generated.
2. Inside the Project Directory
Inside the project directory, the required files for the project building procedure are available. The source files, project building libraries, executables and other binaries are all managed and collected to be placed here. Each new file that you create is created here, and the project knows which files you currently hold and which files you have removed. So overall the directory is just to hold the files for the project. This directory is used as the location for the files and resources when the build process starts.
Figure 2: Inside the project directory.
Now these are the entire files required to run our sample project! The project files, solution files and user preferences are all found here and… Well, there is another a simple Program.cs file found too. All of these files are used to generate the assemblies (which are later placed in the bin folder, displayed above). Technically, if either one of these files are missing (the ones that are required at the compile-time), your project cannot compile. You will get errors and you would either have to create a new project, or edit the profile itself to make sure that the errors are minimized. So, it is recommended that you do not tamper with these files and let the IDE do what it is intended to do.
This is another folder in the project itself and well technically it contains the properties for your project. The properties are of the assembly, the information about the assembly, versioning, etc. are found here. Currently, this folder contains just one file, “AssemblyInfo.cs”.
Figure 3: Properties folder.
This file is used when referencing the assemblies in the projects. You can get more information from MSDN or any other resource that talks about Assembly Information in C# applications.
bin and obj Folders
These folders are used when IDE has finished building a project. They are used to maintain the executables for the project. However, they are not required to be there. Your IDE would itself create these folders when you run the build process, if you have deleted them before.
Just for the sake of demonstration, please see the following image, the executable can be found in the following folder:
Figure 4: Debug executable found in the bin folder.
This “.exe” file can be used to execute the code that we just wrote in the application. But remember, if you previously deleted the folders, you still need to build the project again to find the executables here. Otherwise, the folder would be empty.
Points of Interest
This is another post in the series of Programming C# on Ubuntu. In this post, I have talked about the overview of the project file and directory structure. Where are your executables placed, what files are provided in the templates and which are optional locations.
This was just an introductory post and that is why it is very concise. In an upcoming post, I will talk about cryptographic services provided by MonoDevelop for C# programming on Ubuntu. So, stay tuned for the next publication.