eclipse-ecal · hannemn · Jun 11, 2025 · Jun 10, 2025 · Jun 10, 2025 · Jun 10, 2025
diff --git a/lang/csharp/Eclipse.eCAL.Core.Samples/pubsub/CMakeLists.txt b/lang/csharp/Eclipse.eCAL.Core.Samples/pubsub/CMakeLists.txt
@@ -24,7 +24,7 @@ find_package(eCAL REQUIRED)
 macro(ecal_add_csharp_core_sample sample_name)
   ecal_add_sample(${sample_name} ${sample_name}.cs)
   target_link_libraries(${sample_name} PRIVATE Eclipse.eCAL.Core)
-  set_property(TARGET ${sample_name} PROPERTY FOLDER samples/csharp/core/pubsub)
+  set_property(TARGET ${sample_name} PROPERTY FOLDER samples/csharp/binary/pubsub)
 endmacro()
 
 ecal_add_csharp_core_sample(minimal_events_rec_csharp)

diff --git a/lang/csharp/Eclipse.eCAL.Core.Samples/service/mirror_client_csharp.cs b/lang/csharp/Eclipse.eCAL.Core.Samples/service/mirror_client_csharp.cs
@@ -71,14 +71,18 @@ It may call the methods "echo" and "reverse"
     ServiceMethodInformationList methodInformationList = new ServiceMethodInformationList();
     methodInformationList.Methods.Add(new ServiceMethodInformation("echo", new DataTypeInformation(), new DataTypeInformation()));
     methodInformationList.Methods.Add(new ServiceMethodInformation("reverse", new DataTypeInformation(), new DataTypeInformation()));
-    
+
     ServiceClient mirrorClient = new ServiceClient("mirror", methodInformationList);
-    
+
     /*
       We wait until the client is connected to a server,
       so we don't call methods that are not available.
     */
-    // isConnected() function not implemented in C# yet
+    while (!mirrorClient.IsConnected())
+    {
+      Console.WriteLine("Waiting for a service ...");
+      System.Threading.Thread.Sleep(1000);
+    }
 
     /*
       Allow to alternate between the two methods "echo" and "reverse".
@@ -96,7 +100,7 @@ Create the request payload.
       byte[] request = Encoding.UTF8.GetBytes("stressed");
 
       /*
-        Service call: blocking
+        Service call with response
       */
       List<ServiceResponse> responseList = mirrorClient.CallWithResponse(method, request, (int)Eclipse.eCAL.Core.ServiceClient.DefaultTimeArgument);
 
@@ -112,7 +116,20 @@ Iterate through all responses and print them.
       }
       else
       {
-        Console.WriteLine("Method blocking call failed.");
+        Console.WriteLine("Method call with response failed.");
+      }
+
+      /*
+        Service call with callback
+      */
+      if (!mirrorClient.CallWithCallback(
+        method,
+        request,
+        response => PrintServiceResponse(response),
+        (int)ServiceClient.DefaultTimeArgument)
+      )
+      {
+        Console.WriteLine("Method call with callback failed.");
       }
 
       System.Threading.Thread.Sleep(1000);

diff --git a/lang/csharp/Eclipse.eCAL.Core/include/service/clr_client.h b/lang/csharp/Eclipse.eCAL.Core/include/service/clr_client.h
@@ -23,7 +23,8 @@
  * @file clr_client.h
  * @brief Managed wrapper for the native CServiceClient API.
  *
- * This file provides the managed interface for eCAL service clients.
+ * This file provides the managed interface for eCAL service clients,
+ * including both blocking calls and callback‐based calls.
  */
 
 #include "service/clr_types.h"
@@ -75,10 +76,24 @@ namespace Eclipse {
          */
         List<ServiceResponse^>^ CallWithResponse(System::String^ methodName, array<System::Byte>^ request, int timeoutMs);
 
+        /**
+         * @brief Blocking call with callback.
+         *
+         * Calls the service and invokes `callback` for each response.
+         *
+         * @param methodName The method name.
+         * @param request The request payload as a byte array.
+         * @param callback Managed callback for each response.
+         * @param timeoutMs Maximum time before returning (ms, use DefaultTimeArgument for infinite timeout).
+         *
+         * @return True if the call succeeded.
+         */
+        bool CallWithCallback(System::String^ methodName, array<System::Byte>^ request, ResponseCallback^ callback, int timeoutMs);
+
         /**
          * @brief Retrieve the service name.
          *
-         * @return The service name as a System::System::String^.
+         * @return The service name as a System::String^.
          */
         System::String^ GetServiceName();
 
@@ -104,6 +119,12 @@ namespace Eclipse {
       private:
         /// Pointer to the native CServiceClient instance.
         ::eCAL::CServiceClient* m_native_service_client;
+
+        /**
+         * @brief Helper: wrap a managed ResponseCallback in a native std::function.
+         */
+        static std::function<void(const ::eCAL::SServiceResponse&)>
+          CreateNativeResponseCallback(ResponseCallback^ managed);
       };
 
     } // namespace Core

diff --git a/lang/csharp/Eclipse.eCAL.Core/src/clr_client.cpp b/lang/csharp/Eclipse.eCAL.Core/src/clr_client.cpp
@@ -130,6 +130,15 @@ List<ServiceResponse^>^ ServiceClient::CallWithResponse(String^ methodName, arra
   }
 }
 
+// CallWithCallback: Blocking call with callback
+bool ServiceClient::CallWithCallback(String^ methodName, array<Byte>^ request, ResponseCallback^ callback, int timeoutMs)
+{
+  std::string nm = StringToStlString(methodName);
+  std::string req = ByteArrayToStlString(request);
+  auto nativeCb = CreateNativeResponseCallback(callback);
+  return m_native_service_client->CallWithCallback(nm, req, nativeCb, timeoutMs);
+}
+
 // IsConnected: Check if at least one client instance is connected.
 bool ServiceClient::IsConnected()
 {
@@ -154,3 +163,45 @@ String^ ServiceClient::GetServiceName()
   std::string nativeName = m_native_service_client->GetServiceName();
   return StlStringToString(nativeName);
 }
+
+// Implementation of the native-to-managed response converter
+std::function<void(const ::eCAL::SServiceResponse&)>
+ServiceClient::CreateNativeResponseCallback(ResponseCallback^ managed)
+{
+  // Keep a gcroot to prevent the delegate from being collected
+  gcroot<ResponseCallback^> cb(managed);
+  return [cb](const ::eCAL::SServiceResponse& native)
+  {
+    // Convert native response to managed ServiceResponse
+    ServiceResponse^ resp = gcnew ServiceResponse();
+    resp->CallState        = static_cast<CallState>(native.call_state);
+    resp->ErrorMessage     = StlStringToString(native.error_msg);
+    resp->ServerId = gcnew ServiceId(
+      gcnew EntityId(
+        native.server_id.service_id.entity_id,
+        native.server_id.service_id.process_id,
+        StlStringToString(native.server_id.service_id.host_name)
+      ),
+      StlStringToString(native.server_id.service_name)
+    );
+
+    // Method information
+    auto& mi = native.service_method_information;
+    resp->MethodInformation = gcnew ServiceMethodInformation(
+                                StlStringToString(mi.method_name),
+                                gcnew DataTypeInformation(
+                                  StlStringToString(mi.request_type.name),
+                                  StlStringToString(mi.request_type.encoding),
+                                  StlStringToByteArray(mi.request_type.descriptor)),
+                                gcnew DataTypeInformation(
+                                  StlStringToString(mi.response_type.name),
+                                  StlStringToString(mi.response_type.encoding),
+                                  StlStringToByteArray(mi.response_type.descriptor
5477
))
+                                );
+    resp->RetState         = native.ret_state;
+    resp->Response         = StlStringToByteArray(native.response);
+
+    // Invoke user callback
+    cb->Invoke(resp);
+  };
+}