diff --git a/cmake/dotnet.cmake b/cmake/dotnet.cmake
index caf61a3f54..217fc6cfc5 100644
--- a/cmake/dotnet.cmake
+++ b/cmake/dotnet.cmake
@@ -105,7 +105,14 @@ else()
   message(FATAL_ERROR "Unsupported system !")
 endif()
 set(DOTNET_NATIVE_PROJECT ${DOTNET_PACKAGE}.runtime.${RUNTIME_IDENTIFIER})
+message(STATUS ".Net runtime project: ${DOTNET_NATIVE_PROJECT}")
+set(DOTNET_NATIVE_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_NATIVE_PROJECT})
+message(STATUS ".Net runtime project build path: ${DOTNET_NATIVE_PROJECT_DIR}")
+
 set(DOTNET_PROJECT ${DOTNET_PACKAGE})
+message(STATUS ".Net project: ${DOTNET_PROJECT}")
+set(DOTNET_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_PROJECT})
+message(STATUS ".Net project build path: ${DOTNET_PROJECT_DIR}")
 
 # Swig wrap all libraries
 foreach(SUBPROJECT IN ITEMS algorithms graph init linear_solver constraint_solver sat util)
@@ -131,7 +138,7 @@ if(DEFINED ENV{DOTNET_SNK})
     )
 else()
   set(DOTNET_SNK_PROJECT CreateSigningKey)
-  set(DOTNET_SNK_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_SNK_PROJECT})
+  set(DOTNET_SNK_PROJECT_DIR ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_SNK_PROJECT})
   add_custom_command(
     OUTPUT ${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
     COMMAND ${CMAKE_COMMAND} -E copy_directory
@@ -141,103 +148,92 @@ else()
     --project ${DOTNET_SNK_PROJECT}/${DOTNET_SNK_PROJECT}.csproj
     /or-tools.snk
     BYPRODUCTS
-      ${DOTNET_SNK_PROJECT_PATH}/bin
-      ${DOTNET_SNK_PROJECT_PATH}/obj
+      ${DOTNET_SNK_PROJECT_DIR}/bin
+      ${DOTNET_SNK_PROJECT_DIR}/obj
     COMMENT "Generate or-tools.snk using CreateSigningKey project"
     WORKING_DIRECTORY dotnet
     VERBATIM
     )
 endif()
 
+file(MAKE_DIRECTORY ${DOTNET_PACKAGES_DIR})
 ############################
 ##  .Net Runtime Package  ##
 ############################
-message(STATUS ".Net runtime project: ${DOTNET_NATIVE_PROJECT}")
-set(DOTNET_NATIVE_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_NATIVE_PROJECT})
-message(STATUS ".Net runtime project build path: ${DOTNET_NATIVE_PROJECT_PATH}")
-
-file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/dotnet/packages)
-
 # *.csproj.in contains:
 # CMake variable(s) (@PROJECT_NAME@) that configure_file() can manage and
 # generator expression ($<TARGET_FILE:...>) that file(GENERATE) can manage.
 configure_file(
   ${PROJECT_SOURCE_DIR}/ortools/dotnet/${DOTNET_PACKAGE}.runtime.csproj.in
-  ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj.in
+  ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj.in
   @ONLY)
 file(GENERATE
-  OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
-  INPUT ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj.in)
+  OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
+  INPUT ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj.in)
 
 add_custom_command(
-  OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj
-  DEPENDS ${DOTNET_NATIVE_PROJECT_PATH}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
+  OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj
+  DEPENDS ${DOTNET_NATIVE_PROJECT_DIR}/$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in
   COMMAND ${CMAKE_COMMAND} -E copy ./$<CONFIG>/${DOTNET_NATIVE_PROJECT}.csproj.in ${DOTNET_NATIVE_PROJECT}.csproj
-  WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_PATH}
+  WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_DIR}
 )
 
 add_custom_command(
-  OUTPUT ${DOTNET_NATIVE_PROJECT_PATH}/timestamp
+  OUTPUT ${DOTNET_NATIVE_PROJECT_DIR}/timestamp
   COMMAND ${DOTNET_EXECUTABLE} build -c Release /p:Platform=x64 ${DOTNET_NATIVE_PROJECT}.csproj
   COMMAND ${DOTNET_EXECUTABLE} pack -c Release ${DOTNET_NATIVE_PROJECT}.csproj
-  COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_NATIVE_PROJECT_PATH}/timestamp
+  COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_NATIVE_PROJECT_DIR}/timestamp
   DEPENDS
-    ${DOTNET_NATIVE_PROJECT_PATH}/${DOTNET_NATIVE_PROJECT}.csproj
+    ${DOTNET_NATIVE_PROJECT_DIR}/${DOTNET_NATIVE_PROJECT}.csproj
     ${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
     Dotnet${PROJECT_NAME}_proto
     google-ortools-native
   BYPRODUCTS
-    ${DOTNET_NATIVE_PROJECT_PATH}/bin
-    ${DOTNET_NATIVE_PROJECT_PATH}/obj
-  COMMENT "Generate .Net native package ${DOTNET_NATIVE_PROJECT} (${DOTNET_NATIVE_PROJECT_PATH}/timestamp)"
-  WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_PATH}
+    ${DOTNET_NATIVE_PROJECT_DIR}/bin
+    ${DOTNET_NATIVE_PROJECT_DIR}/obj
+  COMMENT "Generate .Net native package ${DOTNET_NATIVE_PROJECT} (${DOTNET_NATIVE_PROJECT_DIR}/timestamp)"
+  WORKING_DIRECTORY ${DOTNET_NATIVE_PROJECT_DIR}
 )
 
 add_custom_target(dotnet_native_package
   DEPENDS
-    ${DOTNET_NATIVE_PROJECT_PATH}/timestamp
+    ${DOTNET_NATIVE_PROJECT_DIR}/timestamp
   WORKING_DIRECTORY dotnet)
 
 ####################
 ##  .Net Package  ##
 ####################
-message(STATUS ".Net project: ${DOTNET_PROJECT}")
-set(DOTNET_PROJECT_PATH ${PROJECT_BINARY_DIR}/dotnet/${DOTNET_PROJECT})
-message(STATUS ".Net project build path: ${DOTNET_PROJECT_PATH}")
-
-set(PROJECT_DOTNET_DIR ${PROJECT_BINARY_DIR}/dotnet)
-
 configure_file(
   ${PROJECT_SOURCE_DIR}/ortools/dotnet/${DOTNET_PROJECT}.csproj.in
-  ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj.in
+  ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj.in
   @ONLY)
 
 add_custom_command(
-  OUTPUT ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj
-  DEPENDS ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj.in
+  OUTPUT ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj
+  DEPENDS ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj.in
   COMMAND ${CMAKE_COMMAND} -E copy ${DOTNET_PROJECT}.csproj.in ${DOTNET_PROJECT}.csproj
-  WORKING_DIRECTORY ${DOTNET_PROJECT_PATH}
+  WORKING_DIRECTORY ${DOTNET_PROJECT_DIR}
 )
 
 add_custom_command(
-  OUTPUT ${DOTNET_PROJECT_PATH}/timestamp
+  OUTPUT ${DOTNET_PROJECT_DIR}/timestamp
   COMMAND ${DOTNET_EXECUTABLE} build -c Release /p:Platform=x64 ${DOTNET_PROJECT}.csproj
   COMMAND ${DOTNET_EXECUTABLE} pack -c Release ${DOTNET_PROJECT}.csproj
-  COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_PROJECT_PATH}/timestamp
+  COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_PROJECT_DIR}/timestamp
   DEPENDS
     ${PROJECT_BINARY_DIR}/dotnet/or-tools.snk
-    ${DOTNET_PROJECT_PATH}/${DOTNET_PROJECT}.csproj
+    ${DOTNET_PROJECT_DIR}/${DOTNET_PROJECT}.csproj
     dotnet_native_package
   BYPRODUCTS
     dotnet/${DOTNET_PROJECT}/bin
     dotnet/${DOTNET_PROJECT}/obj
-  COMMENT "Generate .Net package ${DOTNET_PROJECT} (${DOTNET_PROJECT_PATH}/timestamp)"
-  WORKING_DIRECTORY ${DOTNET_PROJECT_PATH}
+  COMMENT "Generate .Net package ${DOTNET_PROJECT} (${DOTNET_PROJECT_DIR}/timestamp)"
+  WORKING_DIRECTORY ${DOTNET_PROJECT_DIR}
 )
 
 add_custom_target(dotnet_package ALL
   DEPENDS
-    ${DOTNET_PROJECT_PATH}/timestamp
+    ${DOTNET_PROJECT_DIR}/timestamp
   WORKING_DIRECTORY dotnet)
 
 #################
@@ -255,47 +251,46 @@ function(add_dotnet_test FILE_NAME)
   get_filename_component(COMPONENT_DIR ${FILE_NAME} DIRECTORY)
   get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
 
-  set(DOTNET_TEST_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${TEST_NAME})
-  message(STATUS "build path: ${DOTNET_TEST_PATH}")
-  file(MAKE_DIRECTORY ${DOTNET_TEST_PATH})
+  set(DOTNET_TEST_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${TEST_NAME})
+  message(STATUS "build path: ${DOTNET_TEST_DIR}")
+  file(MAKE_DIRECTORY ${DOTNET_TEST_DIR})
 
   add_custom_command(
-    OUTPUT ${DOTNET_TEST_PATH}/${TEST_NAME}.cs
-    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_TEST_PATH}/
+    OUTPUT ${DOTNET_TEST_DIR}/${TEST_NAME}.cs
+    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_TEST_DIR}/
     MAIN_DEPENDENCY ${FILE_NAME}
     VERBATIM
   )
 
-  set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
   configure_file(
     ${PROJECT_SOURCE_DIR}/ortools/dotnet/Test.csproj.in
-    ${DOTNET_TEST_PATH}/${TEST_NAME}.csproj
+    ${DOTNET_TEST_DIR}/${TEST_NAME}.csproj
     @ONLY)
 
   add_custom_command(
-    OUTPUT ${DOTNET_TEST_PATH}/timestamp
+    OUTPUT ${DOTNET_TEST_DIR}/timestamp
     COMMAND ${DOTNET_EXECUTABLE} build -c Release
-    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_TEST_PATH}/timestamp
+    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_TEST_DIR}/timestamp
     DEPENDS
-      ${DOTNET_TEST_PATH}/${TEST_NAME}.csproj
-      ${DOTNET_TEST_PATH}/${TEST_NAME}.cs
+      ${DOTNET_TEST_DIR}/${TEST_NAME}.csproj
+      ${DOTNET_TEST_DIR}/${TEST_NAME}.cs
       dotnet_package
     BYPRODUCTS
-      ${DOTNET_TEST_PATH}/bin
-      ${DOTNET_TEST_PATH}/obj
-      COMMENT "Compiling .Net ${COMPONENT_NAME}/${TEST_NAME}.cs (${DOTNET_TEST_PATH}/timestamp)"
-    WORKING_DIRECTORY ${DOTNET_TEST_PATH})
+      ${DOTNET_TEST_DIR}/bin
+      ${DOTNET_TEST_DIR}/obj
+      COMMENT "Compiling .Net ${COMPONENT_NAME}/${TEST_NAME}.cs (${DOTNET_TEST_DIR}/timestamp)"
+    WORKING_DIRECTORY ${DOTNET_TEST_DIR})
 
   add_custom_target(dotnet_${COMPONENT_NAME}_${TEST_NAME} ALL
     DEPENDS
-      ${DOTNET_TEST_PATH}/timestamp
+      ${DOTNET_TEST_DIR}/timestamp
     WORKING_DIRECTORY dotnet)
 
   if(BUILD_TESTING)
     add_test(
       NAME dotnet_${COMPONENT_NAME}_${TEST_NAME}
       COMMAND ${DOTNET_EXECUTABLE} test --no-build -c Release
-      WORKING_DIRECTORY ${DOTNET_TEST_PATH})
+      WORKING_DIRECTORY ${DOTNET_TEST_DIR})
   endif()
   message(STATUS "Configuring test ${FILE_NAME} done")
 endfunction()
@@ -316,48 +311,47 @@ function(add_dotnet_sample FILE_NAME)
   get_filename_component(COMPONENT_DIR ${SAMPLE_DIR} DIRECTORY)
   get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
 
-  set(DOTNET_SAMPLE_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${SAMPLE_NAME})
-  message(STATUS "build path: ${DOTNET_SAMPLE_PATH}")
-  file(MAKE_DIRECTORY ${DOTNET_SAMPLE_PATH})
+  set(DOTNET_SAMPLE_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${SAMPLE_NAME})
+  message(STATUS "build path: ${DOTNET_SAMPLE_DIR}")
+  file(MAKE_DIRECTORY ${DOTNET_SAMPLE_DIR})
 
   add_custom_command(
-    OUTPUT ${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.cs
-    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_SAMPLE_PATH}/
+    OUTPUT ${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.cs
+    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_SAMPLE_DIR}/
     MAIN_DEPENDENCY ${FILE_NAME}
     VERBATIM
   )
 
-  set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
   configure_file(
     ${PROJECT_SOURCE_DIR}/ortools/dotnet/Sample.csproj.in
-    ${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.csproj
+    ${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.csproj
     @ONLY)
 
   add_custom_command(
-    OUTPUT ${DOTNET_SAMPLE_PATH}/timestamp
+    OUTPUT ${DOTNET_SAMPLE_DIR}/timestamp
     COMMAND ${DOTNET_EXECUTABLE} build -c Release
     COMMAND ${DOTNET_EXECUTABLE} pack -c Release
-    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_SAMPLE_PATH}/timestamp
+    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_SAMPLE_DIR}/timestamp
     DEPENDS
-      ${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.csproj
-      ${DOTNET_SAMPLE_PATH}/${SAMPLE_NAME}.cs
+      ${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.csproj
+      ${DOTNET_SAMPLE_DIR}/${SAMPLE_NAME}.cs
       dotnet_package
     BYPRODUCTS
-      ${DOTNET_SAMPLE_PATH}/bin
-      ${DOTNET_SAMPLE_PATH}/obj
-    COMMENT "Compiling .Net ${COMPONENT_NAME}/${SAMPLE_NAME}.cs (${DOTNET_SAMPLE_PATH}/timestamp)"
-    WORKING_DIRECTORY ${DOTNET_SAMPLE_PATH})
+      ${DOTNET_SAMPLE_DIR}/bin
+      ${DOTNET_SAMPLE_DIR}/obj
+    COMMENT "Compiling .Net ${COMPONENT_NAME}/${SAMPLE_NAME}.cs (${DOTNET_SAMPLE_DIR}/timestamp)"
+    WORKING_DIRECTORY ${DOTNET_SAMPLE_DIR})
 
   add_custom_target(dotnet_${COMPONENT_NAME}_${SAMPLE_NAME} ALL
     DEPENDS
-      ${DOTNET_SAMPLE_PATH}/timestamp
+      ${DOTNET_SAMPLE_DIR}/timestamp
     WORKING_DIRECTORY dotnet)
 
   if(BUILD_TESTING)
     add_test(
       NAME dotnet_${COMPONENT_NAME}_${SAMPLE_NAME}
       COMMAND ${DOTNET_EXECUTABLE} run --no-build -c Release
-      WORKING_DIRECTORY ${DOTNET_SAMPLE_PATH})
+      WORKING_DIRECTORY ${DOTNET_SAMPLE_DIR})
   endif()
   message(STATUS "Configuring sample ${FILE_NAME} done")
 endfunction()
@@ -377,49 +371,48 @@ function(add_dotnet_example FILE_NAME)
   get_filename_component(COMPONENT_DIR ${FILE_NAME} DIRECTORY)
   get_filename_component(COMPONENT_NAME ${COMPONENT_DIR} NAME)
 
-  set(DOTNET_EXAMPLE_PATH ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${EXAMPLE_NAME})
-  message(STATUS "build path: ${DOTNET_EXAMPLE_PATH}")
-  file(MAKE_DIRECTORY ${DOTNET_EXAMPLE_PATH})
+  set(DOTNET_EXAMPLE_DIR ${PROJECT_BINARY_DIR}/dotnet/${COMPONENT_NAME}/${EXAMPLE_NAME})
+  message(STATUS "build path: ${DOTNET_EXAMPLE_DIR}")
+  file(MAKE_DIRECTORY ${DOTNET_EXAMPLE_DIR})
 
   add_custom_command(
-    OUTPUT ${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.cs
-    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_EXAMPLE_PATH}/
+    OUTPUT ${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.cs
+    COMMAND ${CMAKE_COMMAND} -E copy ${FILE_NAME} ${DOTNET_EXAMPLE_DIR}/
     MAIN_DEPENDENCY ${FILE_NAME}
     VERBATIM
   )
 
-  set(DOTNET_PACKAGES_DIR "${PROJECT_BINARY_DIR}/dotnet/packages")
   set(SAMPLE_NAME ${EXAMPLE_NAME})
   configure_file(
     ${PROJECT_SOURCE_DIR}/ortools/dotnet/Sample.csproj.in
-    ${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.csproj
+    ${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.csproj
     @ONLY)
 
   add_custom_command(
-    OUTPUT ${DOTNET_EXAMPLE_PATH}/timestamp
+    OUTPUT ${DOTNET_EXAMPLE_DIR}/timestamp
     COMMAND ${DOTNET_EXECUTABLE} build -c Release
     COMMAND ${DOTNET_EXECUTABLE} pack -c Release
-    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_EXAMPLE_PATH}/timestamp
+    COMMAND ${CMAKE_COMMAND} -E touch ${DOTNET_EXAMPLE_DIR}/timestamp
     DEPENDS
-      ${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.csproj
-      ${DOTNET_EXAMPLE_PATH}/${EXAMPLE_NAME}.cs
+      ${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.csproj
+      ${DOTNET_EXAMPLE_DIR}/${EXAMPLE_NAME}.cs
       dotnet_package
     BYPRODUCTS
-      ${DOTNET_EXAMPLE_PATH}/bin
-      ${DOTNET_EXAMPLE_PATH}/obj
-      COMMENT "Compiling .Net ${COMPONENT_NAME}/${EXAMPLE_NAME}.cs (${DOTNET_EXAMPLE_PATH}/timestamp)"
-    WORKING_DIRECTORY ${DOTNET_EXAMPLE_PATH})
+      ${DOTNET_EXAMPLE_DIR}/bin
+      ${DOTNET_EXAMPLE_DIR}/obj
+      COMMENT "Compiling .Net ${COMPONENT_NAME}/${EXAMPLE_NAME}.cs (${DOTNET_EXAMPLE_DIR}/timestamp)"
+    WORKING_DIRECTORY ${DOTNET_EXAMPLE_DIR})
 
   add_custom_target(dotnet_${COMPONENT_NAME}_${EXAMPLE_NAME} ALL
     DEPENDS
-      ${DOTNET_EXAMPLE_PATH}/timestamp
+      ${DOTNET_EXAMPLE_DIR}/timestamp
     WORKING_DIRECTORY dotnet)
 
   if(BUILD_TESTING)
     add_test(
       NAME dotnet_${COMPONENT_NAME}_${EXAMPLE_NAME}
       COMMAND ${DOTNET_EXECUTABLE} run --no-build -c Release
-      WORKING_DIRECTORY ${DOTNET_EXAMPLE_PATH})
+      WORKING_DIRECTORY ${DOTNET_EXAMPLE_DIR})
   endif()
   message(STATUS "Configuring example ${FILE_NAME} done")
 endfunction()
diff --git a/makefiles/Makefile.dotnet.mk b/makefiles/Makefile.dotnet.mk
index cb655d24f7..a9dd170db9 100644
--- a/makefiles/Makefile.dotnet.mk
+++ b/makefiles/Makefile.dotnet.mk
@@ -434,7 +434,7 @@ $(TEMP_DOTNET_DIR)/$(DOTNET_ORTOOLS_ASSEMBLY_NAME)/$(DOTNET_ORTOOLS_ASSEMBLY_NAM
  $(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
 	$(SED) -i -e 's/@DOTNET_PACKAGES_DIR@/..\/packages/' \
  $(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
-	$(SED) -i -e 's/@PROJECT_DOTNET_DIR@/..\/..\/ortools\/gen/' \
+	$(SED) -i -e 's/@DOTNET_PROJECT_DIR@/..\/..\/ortools\/gen/' \
  $(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
 	$(SED) -i -e 's/@PROJECT_SOURCE_DIR@/..\/../' \
  $(TEMP_DOTNET_DIR)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME)$S$(DOTNET_ORTOOLS_ASSEMBLY_NAME).csproj
diff --git a/ortools/algorithms/csharp/CMakeLists.txt b/ortools/algorithms/csharp/CMakeLists.txt
index f47eab7383..1071160018 100644
--- a/ortools/algorithms/csharp/CMakeLists.txt
+++ b/ortools/algorithms/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE knapsack_solver.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_algorithms
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/algorithms
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/${PROJECT_NAME}/algorithms
   SOURCES knapsack_solver.i)
 
 #target_include_directories(dotnet_algorithms PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/constraint_solver/csharp/CMakeLists.txt b/ortools/constraint_solver/csharp/CMakeLists.txt
index 58a7038f47..1b9218cc98 100644
--- a/ortools/constraint_solver/csharp/CMakeLists.txt
+++ b/ortools/constraint_solver/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE routing.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_constraint_solver
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/constraint_solver
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/constraint_solver
   SOURCES routing.i)
 
 #target_include_directories(dotnet_constraint_solver PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/dotnet/Google.OrTools.csproj.in b/ortools/dotnet/Google.OrTools.csproj.in
index f6e9cbe3cc..4573dd721b 100644
--- a/ortools/dotnet/Google.OrTools.csproj.in
+++ b/ortools/dotnet/Google.OrTools.csproj.in
@@ -31,43 +31,43 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/algorithms/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/algorithms/*.cs">
       <Link>algorithms/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/graph/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/graph/*.cs">
       <Link>graph/%(Filename)%(Extension)</Link>
     </Compile>
     <Compile Include="@PROJECT_SOURCE_DIR@/ortools/graph/csharp/*.cs">
       <Link>graph/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/linear_solver/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/linear_solver/*.cs">
       <Link>linear_solver/%(Filename)%(Extension)</Link>
     </Compile>
     <Compile Include="@PROJECT_SOURCE_DIR@/ortools/linear_solver/csharp/*.cs">
       <Link>linear_solver/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/constraint_solver/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/constraint_solver/*.cs">
       <Link>constraint_solver/%(Filename)%(Extension)</Link>
     </Compile>
     <Compile Include="@PROJECT_SOURCE_DIR@/ortools/constraint_solver/csharp/*.cs">
       <Link>constraint_solver/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/init/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/init/*.cs">
       <Link>init/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/sat/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/sat/*.cs">
       <Link>sat/%(Filename)%(Extension)</Link>
     </Compile>
     <Compile Include="@PROJECT_SOURCE_DIR@/ortools/sat/csharp/*.cs">
       <Link>sat/%(Filename)%(Extension)</Link>
     </Compile>
 
-    <Compile Include="@PROJECT_DOTNET_DIR@/ortools/util/*.cs">
+    <Compile Include="@DOTNET_PROJECT_DIR@/util/*.cs">
       <Link>util/%(Filename)%(Extension)</Link>
     </Compile>
     <Compile Include="@PROJECT_SOURCE_DIR@/ortools/util/csharp/*.cs">
diff --git a/ortools/graph/csharp/CMakeLists.txt b/ortools/graph/csharp/CMakeLists.txt
index 2c16eec19c..ab20ed8b46 100644
--- a/ortools/graph/csharp/CMakeLists.txt
+++ b/ortools/graph/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE graph.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_graph
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/graph
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/graph
   SOURCES graph.i)
 
 #target_include_directories(dotnet_graph PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/init/csharp/CMakeLists.txt b/ortools/init/csharp/CMakeLists.txt
index eed1f53329..1fbf7f8878 100644
--- a/ortools/init/csharp/CMakeLists.txt
+++ b/ortools/init/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE init.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_init
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/init
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/init
   SOURCES init.i)
 
 #target_include_directories(dotnet_init PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/linear_solver/csharp/CMakeLists.txt b/ortools/linear_solver/csharp/CMakeLists.txt
index 774faefaf4..16302e3ee4 100644
--- a/ortools/linear_solver/csharp/CMakeLists.txt
+++ b/ortools/linear_solver/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE linear_solver.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_linear_solver
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/linear_solver
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/linear_solver
   SOURCES linear_solver.i)
 
 #target_include_directories(dotnet_linear_solver PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/sat/csharp/CMakeLists.txt b/ortools/sat/csharp/CMakeLists.txt
index daed87571d..ab223bf899 100644
--- a/ortools/sat/csharp/CMakeLists.txt
+++ b/ortools/sat/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE sat.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_sat
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/sat
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/sat
   SOURCES sat.i)
 
 #target_include_directories(dotnet_sat PRIVATE ${DOTNET_INCLUDE_DIRS})
diff --git a/ortools/util/csharp/CMakeLists.txt b/ortools/util/csharp/CMakeLists.txt
index 96784aec52..37a1069588 100644
--- a/ortools/util/csharp/CMakeLists.txt
+++ b/ortools/util/csharp/CMakeLists.txt
@@ -8,7 +8,7 @@ set_property(SOURCE sorted_interval_list.i PROPERTY COMPILE_OPTIONS
 swig_add_library(dotnet_util
   TYPE OBJECT
   LANGUAGE csharp
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/dotnet/${PROJECT_NAME}/util
+  OUTPUT_DIR ${DOTNET_PROJECT_DIR}/util
   SOURCES sorted_interval_list.i)
 
 #target_include_directories(dotnet_util PRIVATE ${DOTNET_INCLUDE_DIRS})