8wDlpd.png
8wDFp9.png
8wDEOx.png
8wDMfH.png
8wDKte.png

Autodesk 平台服务 (Forge) .NET SDK OssClient.DeleteObjectAsync() 和 OssClient.GetObjectDetailsAsync() NullReferenceException

verfluecht 3月前

181 0

我可以使用本地文件在指定的存储桶中成功创建新对象,如下所示。可以使用 OSS 管理器工具进行验证。但是,我无法获取该对象的详细信息或

我可以使用本地文件在指定的存储桶中成功创建新对象,如下所示。可以使用 OSS 管理器工具

Screenshot .

但是,我无法获取该对象的详细信息或删除该对象。调用被抛出“System.NullReferenceException”,没有任何详细信息。访问令牌和存储桶密钥与上传图像中显示的相同,因此它们不为空。

Screenshot

所有范围都添加到令牌中以确保这不是问题,即使它会引发不同的错误。

Screenshot

成功执行这些方法的正确方法是什么?

我尝试使用对象的名称、objectId 和 objectKey,但没有成功。

帖子版权声明 1、本帖标题:Autodesk 平台服务 (Forge) .NET SDK OssClient.DeleteObjectAsync() 和 OssClient.GetObjectDetailsAsync() NullReferenceException
    本站网址:http://xjnalaquan.com/
2、本网站的资源部分来源于网络,如有侵权,请联系站长进行删除处理。
3、会员发帖仅代表会员个人观点,并不代表本站赞同其观点和对其真实性负责。
4、本站一律禁止以任何方式发布或转载任何违法的相关信息,访客发现请向站长举报
5、站长邮箱:yeweds@126.com 除非注明,本帖由verfluecht在本站《.net》版块原创发布, 转载请注明出处!
最新回复 (0)
  • 我希望能够在 C# 控制台应用程序中捕获 Ctrl+C,以便在退出之前进行一些清理。最好的方法是什么?

    我希望能够在 C# 控制台应用程序中捕获Ctrl+C,以便在退出之前进行一些清理。最好的方法是什么?

  • 我正在使用干净的架构和 FinBuckle 7.0.1 创建多租户 API。我的单元测试运行良好,我可以在客户端标头中设置租户标识符的功能测试也运行良好,

    我使用干净的架构和 FinBuckle 7.0.1 创建了一个多租户 API。我的单元测试运行良好,并且我可以在客户端标头中设置租户标识符的功能测试也运行良好,但是,我无法运行集成测试,因为 AppDbContext 中的 tenantinfo 实例始终为空。在测试设置期间,我在 docker 中启动了一个新的 SQL 服务器,构建并使用测试数据填充数据库,DbContext 可以正常工作。但在测试执行期间,tenantindo 始终为空。

    是否有人成功创建了通过 WebApplicationFactory '注入'租户的集成测试?

    我已经尝试了好几天,并使用了在网上能找到的所有建议,甚至使用了静态租户,但是在测试运行时,AppDbContext 中的租户实例总是为空。

    如有任何建议我将不胜感激。

  • 您可以使用 TaskCompletionSource 将转换 Console.CancelKeyPress Task 可直接等待的:

    private static Task GetConsoleCancelKeyPressTask()
    {
        var taskCompletionSource = new TaskCompletionSource();
    
        Console.CancelKeyPress += (sender, eventArgs) =>
        {
            // We handled this event, nobody else should do stuff.
            eventArgs.Cancel = true;
    
            Console.WriteLine("Cancellation requested...");
            taskCompletionSource.SetResult();
        };
    
        // This will "resolve" when the 'SetResult' method is called.
        return taskCompletionSource.Task;
    }
    
  • Console.TreatControlCAsInput = true; 对我有用。

  • 我可以在退出之前进行一些清理。最好的方法是什么?这就是真正的目标:陷阱退出,制作你自己的东西。而且上面的答案都没有做对。因为,Ctrl+C 只是退出应用程序的众多方法之一。

    在 dotnet c# 中需要什么 - 所谓的 取消令牌 传递给 Host.RunAsync(ct) 然后,在退出信号陷阱中,对于 Windows 来说,它将是

        private static readonly CancellationTokenSource cts = new CancellationTokenSource();
        public static int Main(string[] args)
        {
            // For gracefull shutdown, trap unload event
            AppDomain.CurrentDomain.ProcessExit += (sender, e) =>
            {
                cts.Cancel();
                exitEvent.Wait();
            };
    
            Console.CancelKeyPress += (sender, e) =>
            {
                cts.Cancel();
                exitEvent.Wait();
            };
    
            host.RunAsync(cts);
            Console.WriteLine("Shutting down");
            exitEvent.Set();
            return 0;
         }
    

    ...

  • 这个问题与以下问题非常相似:

    捕获控制台退出 C#

    以下是我解决这个问题的方法,以及处理用户按下 X 和 Ctrl-C 的情况。请注意 ManualResetEvents 的使用。这将导致主线程进入休眠状态,从而释放 CPU 以在等待退出或清理时处理其他线程。注意:必须在主线程结束时设置 TerminationCompletedEvent。如果不这样做,由于操作系统在终止应用程序时超时,会导致不必要的终止延迟。

    namespace CancelSample
    {
        using System;
        using System.Threading;
        using System.Runtime.InteropServices;
    
        internal class Program
        {
            /// <summary>
            /// Adds or removes an application-defined HandlerRoutine function from the list of handler functions for the calling process
            /// </summary>
            /// <param name="handler">A pointer to the application-defined HandlerRoutine function to be added or removed. This parameter can be NULL.</param>
            /// <param name="add">If this parameter is TRUE, the handler is added; if it is FALSE, the handler is removed.</param>
            /// <returns>If the function succeeds, the return value is true.</returns>
            [DllImport("Kernel32")]
            private static extern bool SetConsoleCtrlHandler(ConsoleCloseHandler handler, bool add);
    
            /// <summary>
            /// The console close handler delegate.
            /// </summary>
            /// <param name="closeReason">
            /// The close reason.
            /// </param>
            /// <returns>
            /// True if cleanup is complete, false to run other registered close handlers.
            /// </returns>
            private delegate bool ConsoleCloseHandler(int closeReason);
    
            /// <summary>
            ///  Event set when the process is terminated.
            /// </summary>
            private static readonly ManualResetEvent TerminationRequestedEvent;
    
            /// <summary>
            /// Event set when the process terminates.
            /// </summary>
            private static readonly ManualResetEvent TerminationCompletedEvent;
    
            /// <summary>
            /// Static constructor
            /// </summary>
            static Program()
            {
                // Do this initialization here to avoid polluting Main() with it
                // also this is a great place to initialize multiple static
                // variables.
                TerminationRequestedEvent = new ManualResetEvent(false);
                TerminationCompletedEvent = new ManualResetEvent(false);
                SetConsoleCtrlHandler(OnConsoleCloseEvent, true);
            }
    
            /// <summary>
            /// The main console entry point.
            /// </summary>
            /// <param name="args">The commandline arguments.</param>
            private static void Main(string[] args)
            {
                // Wait for the termination event
                while (!TerminationRequestedEvent.WaitOne(0))
                {
                    // Something to do while waiting
                    Console.WriteLine("Work");
                }
    
                // Sleep until termination
                TerminationRequestedEvent.WaitOne();
    
                // Print a message which represents the operation
                Console.WriteLine("Cleanup");
    
                // Set this to terminate immediately (if not set, the OS will
                // eventually kill the process)
                TerminationCompletedEvent.Set();
            }
    
            /// <summary>
            /// Method called when the user presses Ctrl-C
            /// </summary>
            /// <param name="reason">The close reason</param>
            private static bool OnConsoleCloseEvent(int reason)
            {
                // Signal termination
                TerminationRequestedEvent.Set();
    
                // Wait for cleanup
                TerminationCompletedEvent.WaitOne();
    
                // Don't run other handlers, just exit.
                return true;
            }
        }
    }
    
  • 从 Linux 上的 .NET 6 开始,我可以证明挂钩 ProcessExit 确实有效。如文档所述,这会捕获 SIGTERM。

  • 截至 2022 年,Console.CancelKeyPress 对我来说一直有效。Win11、.NET 6、NativeAOT 编译的应用程序、OutputType = Exe。

  • 引用 10

    我的答案是用 .net core 5 编写的,并测试了 Ubuntu 21.10,这是我的主要操作系统。

  • 不对。本页上写的所有解决方案都无法在 LINUX 上运行。Console.In.Peek()、CurrentDomain.blah blah()、Console.CancelKeyPress() 它们都只在 Windows 中运行,在 linux 中根本不起作用。这听起来可能很简单,但当你的应用程序作为基于控制台的应用程序在容器中运行时,这是一个大问题,因为 kubernetes 必须将其杀死,而不是正常结束它

  • 检测 SIGTERM 和Ctrl+C

    CancellationTokenSource ctSource = new();
    CancellationToken ct = ctSource.Token;
    
    void ExitHandler()
    {
        // You can add any arbitrary global clean up
        Console.WriteLine("Exiting...");
        ctSource.Cancel();
    }
    
    // Assign exit handler to be called when the process is terminated
    // or the user hits CTRL+C
    AppDomain.CurrentDomain.ProcessExit += (sender, args) => ExitHandler();
    Console.CancelKeyPress += (sender, args) => ExitHandler();
    
    // Then you can use the cancellation token to check for exit:
    Console.WriteLine("Ready to gracefully shut down!");
    while (!ct.IsCancellationRequested)
    {
        Console.WriteLine($"Exit not detected, waiting another 10s.");
        Task.Delay(10000, ct).Wait(ct);
    }
    
  • 我之所以喜欢这个,是因为这是唯一一个能给出完整答案的答案。这个答案很全面,可以让你在任务调度程序下运行程序,而无需用户参与。你仍然有机会进行清理。在你的项目中使用 NLOG,你就有了一些可管理的东西。我想知道它是否会在 .NET Core 2 或 3 中编译。

  • 这是一个完整的工作示例。粘贴到空的 C# 控制台项目中:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;
    
    namespace TestTrapCtrlC {
        public class Program {
            static bool exitSystem = false;
    
            #region Trap application termination
            [DllImport("Kernel32")]
            private static extern bool SetConsoleCtrlHandler(EventHandler handler, bool add);
    
            private delegate bool EventHandler(CtrlType sig);
            static EventHandler _handler;
    
            enum CtrlType {
                CTRL_C_EVENT = 0,
                CTRL_BREAK_EVENT = 1,
                CTRL_CLOSE_EVENT = 2,
                CTRL_LOGOFF_EVENT = 5,
                CTRL_SHUTDOWN_EVENT = 6
            }
    
            private static bool Handler(CtrlType sig) {
                Console.WriteLine("Exiting system due to external CTRL-C, or process kill, or shutdown");
    
                //do your cleanup here
                Thread.Sleep(5000); //simulate some cleanup delay
    
                Console.WriteLine("Cleanup complete");
    
                //allow main to run off
                exitSystem = true;
    
                //shutdown right away so there are no lingering threads
                Environment.Exit(-1);
    
                return true;
            }
            #endregion
    
            static void Main(string[] args) {
                // Some biolerplate to react to close window event, CTRL-C, kill, etc
                _handler += new EventHandler(Handler);
                SetConsoleCtrlHandler(_handler, true);
    
                //start your multi threaded program here
                Program p = new Program();
                p.Start();
    
                //hold the console so it doesn’t run off the end
                while (!exitSystem) {
                    Thread.Sleep(500);
                }
            }
    
            public void Start() {
                // start a thread and start doing some processing
                Console.WriteLine("Thread started, processing..");
            }
        }
    }
    
  • 如果 Main 函数被 Console.ReadLine 暂停,则 Ctrl + C 将向其传递一个空字符串。如果 Main 执行清理并在 Read 之后返回,则会导致并发问题,有人知道如何解决这个问题吗?这需要同步两个线程的状态比较和定义的功能,正确的实现方法是什么?

  • 请注意,虽然在 VS 调试控制台窗口中按 Ctrl-C 时会调用 CancelKeyPress 事件处理程序,但设置 Cancel = true 没有任何效果。

  • @pkr298 - 很遗憾人们没有投票支持你的评论,因为这是完全正确的。我会编辑 Jonas 的回答,以澄清人们的想法与 Jonathon 的想法不同(这本身并不坏,但 Jonas 的回答并非如此)

  • 我认为关键在于您将在 while 循环内完成所有工作,并且按 Ctrl+C 不会在 while 迭代中间中断;它会在中断之前完成该迭代。

  • 引用 19

    我想补充一下 Jonas 的回答 。旋转 bool CTRLC+时浪费大量能源.

    更好的解决方案是使用 ManualResetEvent 来实际“等待”CTRL+C

    static void Main(string[] args) {
        var exitEvent = new ManualResetEvent(false);
    
        Console.CancelKeyPress += (sender, eventArgs) => {
                                      eventArgs.Cancel = true;
                                      exitEvent.Set();
                                  };
    
        var server = new MyServer();     // example
        server.Run();
    
        exitEvent.WaitOne();
        server.Stop();
    }
    
  • 注意 - CancelKeyPress 事件是在线程池线程上处理的,这不是很明显:learn.microsoft.com/en-us/dotnet/api/...

返回
作者最近主题: