问题[c#]

我有一个需要MyClass实例化A和初始化的类。所有三个类都继承了。我无法访问这些类的源代码，但是它们的构造函数可能会因某些参数组合而引发异常。我知道在构造函数中抛出异常是一种不好的做法，因为它可能会导致类在内存中处于不一致的状态（不变违反）。因此，我没有使用直接构造函数，而是使用在内部进行初始化的工厂方法，并且。如果至少有一个类，并且已引发异常，则该函数也会引发异常。我知道如果我无法创建，那么我至少应该释放该类并引发异常。我还知道，如果我无法创建该类，我至少应该释放先前创建的和，然后在中引发异常。BCIDisposableABCMyClass.Create()ABCCreateABCBACABCreate

请告诉我是否有一个好的模式或代码示例，如果我无法构建类，我该如何清除以前初始化的部分MyClass？
如果有多于三个部分怎么办？我正在考虑使用堆栈Stack<IDisposable>来清理各个部分。

应
@user7860670 的要求添加一个最低限度可重现的示例。看来这段文字太难理解了：

class A: IDisposable
{
  private readonly int p_value;

  public A(int value)
  {
    ArgumentOutOfRangeException.ThrowIfNegative(value);
    p_value = value;
  }

  public void Print()
  {
    Console.WriteLine($"Value is: {p_value}");
  }

  public void Dispose()
  {
    Console.WriteLine("A disposed");
  }
}


class B : IDisposable
{
  private readonly int p_value;

  public B(int value)
  {
    ArgumentOutOfRangeException.ThrowIfLessThan(value, 10);
    p_value = value;
  }

  public void Print()
  {
    Console.WriteLine($"Value is: {p_value}");
  }

  public void Dispose()
  {
    Console.WriteLine("B disposed");
  }
}


class C : IDisposable
{
  private readonly int p_value;

  public C(int value)
  {
    ArgumentOutOfRangeException.ThrowIfLessThan(value, 20);
    p_value = value;
  }

  public void Print()
  {
    Console.WriteLine($"Value is: {p_value}");
  }

  public void Dispose()
  {
    Console.WriteLine("C disposed");
  }
}

class MyClass
{
  private readonly A a;
  private readonly B b;
  private readonly C c;

  protected MyClass(A _a, B _b, C _c) { a = _a; b = _b; c = _c;}

  public MyClass Create(int _value)
  {
    // Maybe throw error
    A a = new A(_value);

    // Maybe throw error
    // Need free A
    B b = new B(_value);

    // Maybe throw error
    // Need free A
    // Need free B
    C c = new C(_value);

    return new (a, b, c);
  }
}

在我的游戏中，玩家是一把在光标后面旋转的枪。问题是，当枪在地上时，它会开始抽搐，与地面碰撞并自行移动，特别是当我开始移动光标时。负责跟踪光标，射击等的代码。用 FixedUpdate 编写，因此问题很可能不在于此。请提供意见，我在论坛上找不到任何关于我的问题的答案，虽然有类似的答案，但他们建议我只在 FixedUpdate 中编写代码。

澄清：除圆形对撞机外，所有类型的对撞机都会发生此类碰撞冲突。

以防万一我会插入一段代码：

public void LookDirection()

{

    mousPos = Camera.ScreenToWorldPoint(Input.mousePosition);

    lookDir = mousPos - rigid_B.position;

    float rotAngle = Mathf.Atan2(lookDir.y, lookDir.x) * Mathf.Rad2Deg + deltaAngle;

    rigid_B.rotation = rotAngle;
}

很长一段时间以来我一直无法找到我的问题的答案。 BackgroundService 是否移至单独的线程？我去论坛上看到答案说后台任务被标记为LongRunning，并且每个后台服务都分配了一个单独的线程，但是在实验过程中

class TestService(ILogger<s> loger) : BackgroundService
{
    private readonly ILogger<s> _loger = loger;
    protected override  Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _loger.LogInformation("Фоновая задача запущена");
        
        while (!stoppingToken.IsCancellationRequested)
        {
             
            _loger.LogInformation("Цикл");
        }
       
    }
}

整个应用程序冻结并且无法启动但是如果在第一行await Task.Yield()或另一行包含带有异步操作的 await 中添加，则应用程序将成功启动，并且任务随后将继续运行。这是什么意思。后台任务不是在单独的线程中运行，而是在主线程中运行？或者它是在第一个之前在主线程中执行await，然后移至单独的线程？

我编写了一个这样的计算器，我也在这里找到了控制台选项，我仍然只是弄清楚它是如何工作的，问题是添加之后，结果变量中会放置零，因此代码无法正常工作。

using System.Security.Cryptography.X509Certificates;

namespace ConsoleApp3
{
    public class Program
    {
        
        public static int val1 = 1;
        public static int val2 = 2;
        public static int result;
        public static bool ActionResult = false;

        static int Slozhenie(int val1, int val2, int result, bool ActionResult)
        {
            ActionResult = true;
            result = val1 + val2;
            return result;
        }

        static int Vychitanie(int val1, int val2, int result)
        {
            result = val1 - val2 ;
            bool ActionResult = true;
            return result;
        }

        static int Umnozhenie(int val1, int val2, int result)
        {
            result = val1 * val2;
            bool ActionResult = true;
            return result;
        }

        static int Delenie(int val1, int val2, int result)
        {
            result = val1 / val2;
            bool ActionResult = true;
            return result;
        }

        static int SlozhenieAfter(int val2, int result, bool ActionResult)
        {
            ActionResult = true;
            result = result * val2;
            return result;
        }
        public static int Start()
        {
            ActionResult = true;
           // done: // запускает все сначала
            string[] menuItems = new string[] { "Сложение", "Вычитание", "Деление", "Умножение" };

            Console.WriteLine("Меню\n");

            int row = Console.CursorTop;
            int col = Console.CursorLeft;
            int index = 0;
            while (true)
            {
                DrawMenu(menuItems, row, col, index);
                switch (Console.ReadKey(true).Key)
                {
                    case ConsoleKey.DownArrow:
                        if (index < menuItems.Length - 1)
                            index++;
                        break;
                    case ConsoleKey.UpArrow:
                        if (index > 0)
                            index--;
                        break;

                    case ConsoleKey.Enter:

                        switch (index)

                        {
                            case 0:
                                Console.WriteLine("\nРезультат сложения равен: " + Slozhenie(val1, val2, result, ActionResult));
                                return 1;
                            case 1:
                                Console.WriteLine("\nРезультат вычитания равен: " + Vychitanie(val1, val2, result));
                                return Vychitanie(val1, val2, result);
                            case 2:
                                Console.WriteLine("\nРезультат деления равен: " + Delenie(val1, val2, result));
                                return Delenie(val1, val2, result);
                            case 3:
                                Console.WriteLine("\nРезультат умножения равен: " + Umnozhenie(val1, val2, result));
                                return Umnozhenie(val1, val2, result);
                        }

                        break;

                }
            }
        }

        public static int StartAfter ()
        {
        done1: // запускает все сначала
            string[] menuItems = new string[] { "Сложение", "Вычитание", "Деление", "Умножение" };

            Console.WriteLine("Меню\n");

            int row = Console.CursorTop;
            int col = Console.CursorLeft;
            int index = 0;
            while (true)
            {
                DrawMenu(menuItems, row, col, index);
                switch (Console.ReadKey(true).Key)
                {
                    case ConsoleKey.DownArrow:
                        if (index < menuItems.Length - 1)
                            index++;
                        break;
                    case ConsoleKey.UpArrow:
                        if (index > 0)
                            index--;
                        break;

                    case ConsoleKey.Enter:

                        switch (index)

                        {
                            case 0:
                                Console.WriteLine("\nРезультат сложения равен: " + SlozhenieAfter(val2, result, ActionResult));
                                return 1;

                            case 1:
                                Console.WriteLine("\nРезультат вычитания равен: " + Vychitanie(val1, val2, result));
                                goto done1;
                            case 2:
                                Console.WriteLine("\nРезультат деления равен: " + Delenie(val1, val2, result));
                                goto done1;
                            case 3:
                                Console.WriteLine("\nРезультат умножения равен: " + Umnozhenie(val1, val2, result));
                                goto done1;
                        }

                        break;

                }
            }
        }
        static void DrawMenu(string[] items, int row, int col, int index)
        {
            Console.SetCursorPosition(col, row);
            for (int i = 0; i < items.Length; i++)
            {
                if (i == index)
                {
                    Console.BackgroundColor = Console.ForegroundColor;
                    Console.ForegroundColor = ConsoleColor.Black;
                }
                Console.WriteLine(items[i]);
                Console.ResetColor();
            }
            Console.WriteLine();
        }

        public static void Main(string[] args)
        {
            while (true) {
            if (ActionResult)
            {

                StartAfter();

                }
            else
            {

                    Start();
                }
            }
        }
    }
}

 public class User : IdentityUser<int>
 {
     public string FullName { get; set; }

     [Required]
     public int DepartmentId { get; set; }
     public Department Department { get; set; }

     [Required]
     public int PositionId { get; set; }
     public Position Position { get; set; }
 }


 public class Department
 {
     public int Id { get; set; }
     public string Name { get; set; }
     public string? UniqueNumber { get; set; }
 }

public class Position
{
    public int Id { get; set; }
    public string Title { get; set; }
}

现在，如果我删除与用户相关联的部门，该部门也会与用户或职位一起被删除。

这种情况该怎么办？如果职位或部门与用户有关联，则禁止删除，或者建立多对多关系。请告诉我解决这个问题的最佳方法。