我可以在同一个类中实现这两个方法吗？

public class MyClass : Idisposable
{
  // some implementation
  // if i missed to call dispose() method;
  ~MyClass()
  {
  // it means,clear all does not mananage resources 
  // but dont use dispose() method 
  }
  public void dispose()
  {
   // clear resources
   // if i call this method will i can do this:
   GC.SuppressFinalize()
   // it means dont use Finalizw method for this object
  }
}

我对吗？因为我无法理解这个GC.SuppressFinalize()方法？

是的,您可以按照自己的意愿实施这两种方法.

通常,如果对象可以同时具有托管和非托管引用,则正确的模式是：

public class MyClass : Idisposable
{
  ~MyClass()
  {
    dispose(false);
  }
  public void dispose()
  {
    GC.SuppressFinalize(this); 
    dispose(true);
  }
  public virtual void dispose(bool disposing)
  {
    if(disposing)
    {
      // clear MANAGED references
    }
    // free UNMANAGED resources
  }
}

但您可以根据需要实现此功能.这只是一种模式.例如,如果您没有任何非托管资源并且您的类是密封的(因此您可以确定它不会使用任何非托管资源),您可以实现它,就像：

public sealed class MyClass : Idisposable
{
  public void dispose()
  {
    // release managed references
  }
}

忘记终结者了.

在第一个模式中,GC.SuppresFinalize(this)正在做什么,告诉垃圾收集器在释放对象时不应该调用终结器(~MyClass()方法)：如果你专门调用了dispose()那么你已经调用了你的虚拟dispose(bool)函数,为什么要再次调用它？

问题是终结器本身在C#中是不确定的：你不知道什么时候会被调用…你甚至不能保证它甚至会被调用(尽管它会在正常清理过程中被调用)如果它之前没有被调用过,这就是Idisposable存在的原因,它是一种确定性地释放托管对象的方式,并释放并释放由它分配的非托管资源.

如果GC释放了一个对象,那么它所拥有的所有托管引用也将被释放,因此在调用终结器时不需要清除托管引用.

但是,您的应用程序应尽最大努力释放和释放它拥有的任何非托管资源.

如果你忘了dispose(),它们应该有最后的机会被释放(当GC收集对象时,或者在应用程序运行时进行最后的清理).在正常模式中你也可以实现一个终结器,如果你之前还没有完成它,请告诉它清理非托管资源

请注意,与流行的看法相反,对dispose()的调用并不特别,它只是一个方法调用：如果需要,可以将其称为FreeMyObject()或FooBar().它不会使垃圾收集器释放任何内存.通过使用Idisposable有一种模式,它非常重要,它可以获得自己的语言语法结构(使用块),但它只是一种模式.您可以执行与dispose()相同的操作,而无需实现Idisposable.

我的代码使用默认的Idisposable实现模板(模式).

片段：

public void dispose()
{
    dispose(true);

    GC.SuppressFinalize(this);
}

protected virtual void dispose(bool isdisposing)
{
    if (!this.disposed)
    {
        if (isdisposing)
        {
            //cleanup managed resources
        }

        //cleanup unmanaged resources

        this.disposed = true;
    }
}

我的问题：为什么在dispose public方法中调用“GC.SuppressFinalize(this)”？在处理托管资源后,我将在保护方法的“if(isdisposing)”部分放置“GC.SuppressFinalize(this)”.

喜欢这个：

protected virtual void dispose(bool isdisposing)
{
    if (!this.disposed)
    {
       if (isdisposing)
       {
           //cleanup managed resources

           GC.SuppressFinalize(this);
       }

       //cleanup unmanaged resources

       this.disposed = true;
    }
}

我想这是一个明确的模板设计模式.

您的抽象类被设计为处理所需的所有重要/必需的任务(这里,GC.SuppressFinalize(this)),并允许派生类仅覆盖代码的一部分.

这里有两种情况：
代码片段1,SuppressFinalize,处理
Snippet 2,in dispose(true)

这里,Snippet 1,确保始终执行GC.SuppressFinalize.而代码段2,在派生类的支持下执行GC.SuppressFinalize.

因此,通过放置GC.SuppressFinalize,在dispose方法中,您作为类的设计者始终确保无论派生类写入的代码如何,GC.SuppressFinalize都将被执行.

这只是在dispose中编写SuppressFinalize而不是dispose(true)的好处.

我有一个关于图形,弹出窗口和动画的大解决方案.我发现在页面导航期间我有大量内存泄漏.

尝试

因此,我尝试了第一个解决方案：

protected override void OnNavigatedTo(NavigationEventArgs e)
    {
        if (App.RootFrame.CanGoBack)
            App.RootFrame.RemoveBackEntry();
        GC.Collect();
        base.OnNavigatedTo(e);
    }

这来自MSDN和Stackoverflow上的几个来源,应该删除为页面存储的内存.情况并非如此,我不确定代码的MVVM结构是否以某种方式保存信息.然后我尝试实现解构器并在事件被触发时将值强制为null,如：

~SecondScreen()
    {
        In_Game_Crest = null;
        currentviewmodel = null;
    }

这是我为所有页面,弹出窗口和用户控件所做的.然后我再次使用调试来完成代码,并且解析器的页面中没有被解雇.这导致我尝试使用Idisposable和fiddeling与MVVMLight提供的viewmodelLocator,但没有任何成功.

调查

我已阅读以下内容解决此问题：
 StackOverFlow: Finalizer and Dispose

Finalize/Dispose pattern in C#

MSDN: Implementing a Dispose Method

MSDN: Implementing Finalize and Dispose to Clean Up Unmanaged Resources

问题

但它让我感到困惑,而不是帮助了我.我应该如何为我的Windows Phone实现页面的dispose和finalize方法？

由于我正在使用MVVM结构,这些方法应该在viewmodel中实现还是在给定页面后面或两者中实现？

Windows手机的例子将非常感激.

初步尝试使用dispose

我已经阅读了更多有关该主题的内容,并发现最终定型可能不应该写出来？但我仍然不确定.但基于此和上面的第一个MSDN链接,我尝试了以下内容：

private bool disposed = false;

    public void dispose()
    {
        dispose(true);
        // Take yourself off the Finalization queue 
        // to prevent finalization code for this object
        // from executing a second time.
        GC.SuppressFinalize(this);
    }

    protected virtual void dispose(bool disposing)
    {
  // Check to see if dispose has already been called.
  if(!this.disposed)
  {
     // If disposing equals true,dispose all managed 
     // and unmanaged resources.
     if(disposing)
     {
        // dispose managed resources.
         currentView = null;
         popup = null;
         Image1 = null;
         Image2 = null;
     }
          // Release unmanaged resources. If disposing is false,// only the following code is executed.
          this.Content = null;
          // Note that this is not thread safe.
          // Another thread Could start disposing the object
          // after the managed resources are disposed,// but before the disposed flag is set to true.
          // If thread safety is necessary,it must be
          // implemented by the client.

  }
  disposed = true;         
    }

    // Use C# destructor Syntax for finalization code.
    // This destructor will run only if the dispose method 
    // does not get called.
    // It gives your base class the opportunity to finalize.
    // Do not provide destructors in types derived from this class.

    ~FirstPage()
    {
        dispose(false);

    }
    protected override void OnNavigatedFrom(NavigationEventArgs e)
    {
        this.dispose();
        base.OnNavigatedFrom(e);
    }

但是,但是当我到达第二个屏幕时,这只会让我的记忆增加23MB.这再次引出了我的问题,我应该如何以及应该尝试实施什么,以及为什么内存会增加？

this = null,base.dispose()

我已经看到了不同的实现,在dispose函数中使用this = null或使用base.dispose().我认为后者只能在类是Idisposable时使用？这是要走的路吗？如果是这样我该怎么办呢？

使用Microsoft Profiler

所以我使用分析器来验证FirstPage是否被删除

从上图可以看出第一页存在.在评论中,我被告知要查找实例并参考元素.因此我选择了firstpage的实例并得到了：

这里确认FirstPage永远不会被销毁.但是我被困在这里,我应该如何解释这些数据呢？
希望得到一些帮助.

当用户离开页面时实际上不需要处置,再次创建对象的性能影响大于在应用程序处于活动状态期间在内存中具有页面的内存负载.
您应该在从内存中删除对象之间做出决定.再次重新创建同一组对象.
说完这个之后你应该小心导航模型.
如果您在每次用户导航到页面时创建对象而在用户导航时不实际处置,则可能会出现内存问题.
为此,我建议您完全理解应用程序中的PageBase和NavigationHelper或NavigationService类.
你已经提到在应用程序的生命周期内没有从内存中删除FirstPage,根据我的说法是理想的.
将调试点放在代码中可能创建重对象的位置;
导航几次到不同的页面,然后回来.
检查行为,然后您可以自己清楚地了解情况.
对于所有对象,请检查您是否手动调用dispose.
dispose是一个与GarbageCollector完全不同的概念,dispose只是一个开发人员应该遵守的契约,通过调用它来释放他们认为不再需要在内存中维护的资源,因为平台的垃圾收集是在不确定的时间进行的.

在您发布的示例中,我看到您将对象设置为null而未实际处理.设置为null只会更改变量指向的内存位置.
它不会立即破坏对象.一个理想的配置应该如下.

//Call on OnClosing or OnExit or similar context
protected override void dispose(bool isdisposing)
{

        if(isdisposing && !_isdisposed){
         if(disposeableImage != null){
           disposeableImage.dispose();
           disposeableImage = null;
         }
        }
}