WEBVTT

00:00:00.000 --> 00:00:01.680
• 收听本周的
萨马林显示在哪里

00:00:01.680 --> 00:00:03.360
我的好朋友亚历克西在谈话

00:00:03.360 --> 00:00:06.810
关于内存管理
您的应用程序。所以，请调入。

00:00:06.810 --> 00:00:13.200
[音乐]

00:00:13.200 --> 00:00:14.280
欢迎大家回来

00:00:14.280 --> 00:00:15.405
到萨马林秀。

00:00:15.405 --> 00:00:16.650
我是你的主人詹姆斯·蒙特马格诺

00:00:16.650 --> 00:00:17.820
今天，我最好的朋友在

00:00:17.820 --> 00:00:21.270
整个世界亚历克西与
我。怎么样，伙计？

00:00:21.270 --> 00:00:22.905
"我很好你怎么样？

00:00:22.905 --> 00:00:24.960
我做的很棒。
这是美好的一天

00:00:24.960 --> 00:00:26.640
这里在雷德蒙德，华盛顿每天。

00:00:26.640 --> 00:00:27.325
* 是。

00:00:27.325 --> 00:00:29.085
• 现在，您来自我们的手机

00:00:29.085 --> 00:00:31.065
客户咨询
团队，对吗？

00:00:31.065 --> 00:00:31.920
* 这是正确的。

00:00:31.920 --> 00:00:33.450
* 那么，这意味着什么？

00:00:33.450 --> 00:00:35.370
• 这意味着我们与

00:00:35.370 --> 00:00:38.250
我们的客户和我们
建议他们明显。

00:00:38.250 --> 00:00:41.645
但最重要的是，我们与开发人员合作
看看他们如何使用工具，

00:00:41.645 --> 00:00:44.300
他们如何与我们的Xamarin工具工作，

00:00:44.300 --> 00:00:47.560
和什么是常见的
他们面临的陷阱。

00:00:47.560 --> 00:00:48.420
• 完美。

00:00:48.420 --> 00:00:50.205
今天，我想谈谈

00:00:50.205 --> 00:00:52.355
其中之一是内存管理。

00:00:52.355 --> 00:00:53.780
#找到你。是的。这很重要

00:00:53.780 --> 00:00:55.730
因为我们经常说
关于所有很酷的，

00:00:55.730 --> 00:00:57.155
花哨的功能，你可以做，

00:00:57.155 --> 00:01:00.440
但我们想有这个
最佳实践系列

00:01:00.440 --> 00:01:02.340
因为你遇到了麻烦

00:01:02.340 --> 00:01:03.820
确实如此。这太容易了。

00:01:03.820 --> 00:01:06.345
内存管理，
老实说，我是个讨厌的人。

00:01:06.345 --> 00:01:07.770
我真的不知道我只是说

00:01:07.770 --> 00:01:09.560
"他们要杀死
我的应用程序在五秒钟。

00:01:09.560 --> 00:01:11.705
没关系，对吧？但
我不该这样想。

00:01:11.705 --> 00:01:14.210
* 确实如此。这就是我们所看到的

00:01:14.210 --> 00:01:16.850
因为没人在乎
内存管理。

00:01:16.850 --> 00:01:21.300
我们有这么多的记忆
你从不检查它们

00:01:21.300 --> 00:01:24.750
我是说，你最后一次是什么时候
检查应用内存使用情况？

00:01:24.750 --> 00:01:26.250
上次我撞车时

00:01:26.250 --> 00:01:29.510
事实上，我有一个非常
这方面的好例子。

00:01:29.510 --> 00:01:31.910
我告诉你这
是真实世界的例子。

00:01:31.910 --> 00:01:35.120
我在Xamarin要点中有个虫子

00:01:35.120 --> 00:01:38.375
说，当我打电话
这种方法20，000次，

00:01:38.375 --> 00:01:41.570
我的应用程序崩溃，它
是因为我不是

00:01:41.570 --> 00:01:45.155
正确处理
本机 Android 对象，

00:01:45.155 --> 00:01:46.775
一个窗口，一个显示器。

00:01:46.775 --> 00:01:48.170
所以现在的情况是

00:01:48.170 --> 00:01:50.480
我会继续创造它
它永远不会得到

00:01:50.480 --> 00:01:53.135
垃圾收集永远，因为
我从未处理过它。

00:01:53.135 --> 00:01:54.890
这就是我们要走的
谈论今天。

00:01:54.890 --> 00:01:56.925
* 是。棒。让我们做
它。你有什么要给我们的？

00:01:56.925 --> 00:02:00.435
* 所以我们有这个小
带有两个窗口的简单应用程序，

00:02:00.435 --> 00:02:02.745
主屏幕和细节屏幕。

00:02:02.745 --> 00:02:06.375
这是一个非常常见的模式
UI 导航控制器。

00:02:06.375 --> 00:02:09.600
这是一个普通的萨马林
iOS 应用程序，对吗？

00:02:09.600 --> 00:02:10.305
"好的。

00:02:10.305 --> 00:02:12.440
• 我们要做什么
要做的是介绍

00:02:12.440 --> 00:02:14.930
内存泄漏在很多，
许多不同的方式。

00:02:14.930 --> 00:02:19.025
但首先，我想谈谈
与本土世界的差异

00:02:19.025 --> 00:02:23.960
和管理世界
性能和内存。

00:02:23.960 --> 00:02:25.340
所以，每当你有一个过程，

00:02:25.340 --> 00:02:27.995
操作系统给
你是一个内存块。

00:02:27.995 --> 00:02:31.370
你应该意识到
因为一旦你耗尽了内存

00:02:31.370 --> 00:02:33.670
你的应用崩溃或
操作系统杀死它。

00:02:33.670 --> 00:02:35.355
在托管内存中，

00:02:35.355 --> 00:02:40.260
我们的萨马林单获得这些
这个小片内存。

00:02:40.260 --> 00:02:41.630
那时我们应该

00:02:41.630 --> 00:02:43.670
谨慎，我们如何
也使用那块。

00:02:43.670 --> 00:02:44.030
"好的。

00:02:44.030 --> 00:02:46.640
* 所以你仍然应该
知道本地内存，

00:02:46.640 --> 00:02:48.905
现在一旦你和萨马林一起工作

00:02:48.905 --> 00:02:50.320
也了解管理部分。

00:02:50.320 --> 00:02:52.740
# 拿到了.所以你有
本机内存，iOS，

00:02:52.740 --> 00:02:55.980
安卓的零碎，
.NET 托管内存？

00:02:55.980 --> 00:02:56.640
"没错"

00:02:56.640 --> 00:02:57.090
• 完美。

00:02:57.090 --> 00:03:00.530
• 每当创建对象时
你创造，让我们说，

00:03:00.530 --> 00:03:02.330
一个 UI 按钮，您实际上创建

00:03:02.330 --> 00:03:04.950
本机 UI 按钮和
托管 UI 按钮类。

00:03:04.950 --> 00:03:06.680
它们对内存的影响不同。

00:03:06.680 --> 00:03:10.310
它们可能会导致不同的
内存问题，因为有

00:03:10.310 --> 00:03:14.135
也以本地方式收集
垃圾和管理方式。

00:03:14.135 --> 00:03:20.385
在单声道中，我们使用单声道单
生成垃圾回收器。

00:03:20.385 --> 00:03:23.460
在本机世界中，iOS 使用 ARC，

00:03:23.460 --> 00:03:26.680
安卓使用自己的
垃圾收集器，

00:03:26.680 --> 00:03:29.420
但他们应该一起工作
并排，我们应该

00:03:29.420 --> 00:03:32.300
有他们，因为你可以
通过使用它引入问题。

00:03:32.300 --> 00:03:32.690
# 拿到了.

00:03:32.690 --> 00:03:34.640
* 所以第一和

00:03:34.640 --> 00:03:36.950
最简单的方法介绍

00:03:36.950 --> 00:03:40.830
内存问题是订阅
无需取消订阅。

00:03:42.040 --> 00:03:45.680
垃圾回收器应该知道
当有垃圾时。

00:03:45.680 --> 00:03:47.180
但他怎么知道？

00:03:47.180 --> 00:03:49.565
它应该能够建立

00:03:49.565 --> 00:03:53.915
可到达性树图
它从路线开始。

00:03:53.915 --> 00:03:57.320
我们的静态事件、静态变量、

00:03:57.320 --> 00:03:59.350
静态事件或线程滚动调用，

00:03:59.350 --> 00:04:01.910
他们都是可到达的路线和

00:04:01.910 --> 00:04:05.005
垃圾回收器处理
他们作为不是垃圾。

00:04:05.005 --> 00:04:06.810
所以每当你这样订阅时，

00:04:06.810 --> 00:04:09.560
让我们采取连接插件。

00:04:09.560 --> 00:04:11.960
我知道，詹姆斯，你
熟悉此插件。

00:04:11.960 --> 00:04:13.400
"我是。是的。非常如此。

00:04:13.400 --> 00:04:14.960
我确实喜欢。在
在这里，我们是什么？

00:04:14.960 --> 00:04:16.220
订阅事件，

00:04:16.220 --> 00:04:18.610
它可能是任何
事件，如点击事件，

00:04:18.610 --> 00:04:20.360
您有一个传感器更改事件。

00:04:20.360 --> 00:04:22.715
基本上，任何在 .NET 中。

00:04:22.715 --> 00:04:25.970
* 是。是特定的
不仅对萨马林

00:04:25.970 --> 00:04:27.830
这是任何静态事件

00:04:27.830 --> 00:04:31.745
在 .NET 和连接
这里只是一个例子。

00:04:31.745 --> 00:04:35.390
我想说的
可以是任何静态事件或

00:04:35.390 --> 00:04:38.960
提供的任何单例事件。

00:04:38.960 --> 00:04:40.880
所以每当我们这样订阅时，

00:04:40.880 --> 00:04:42.520
比我们说，我们有

00:04:42.520 --> 00:04:47.100
这个小片
连接更改处理程序。

00:04:47.100 --> 00:04:49.655
我们引入了一个小内存泄漏。

00:04:49.655 --> 00:04:54.290
它很小，因为我们的观点是
非常简单和轻巧，

00:04:54.290 --> 00:04:55.400
但这是内存泄漏

00:04:55.400 --> 00:04:57.685
* 所以这是一个内存泄漏，为什么呢？

00:04:57.685 --> 00:05:00.860
* 因为此连接和

00:05:00.860 --> 00:05:03.830
连接更改事件
是静态引用

00:05:03.830 --> 00:05:05.270
为我们的垃圾收集器。

00:05:05.270 --> 00:05:06.980
一旦我们的垃圾
收集器正在尝试

00:05:06.980 --> 00:05:08.810
确定是不是垃圾

00:05:08.810 --> 00:05:11.015
不是因为

00:05:11.015 --> 00:05:14.540
连接更改事件已
对此处理程序的引用，

00:05:14.540 --> 00:05:17.375
这个处理程序实际上处理

00:05:17.375 --> 00:05:21.080
对我们的参考
详细信息查看控制器。

00:05:21.080 --> 00:05:24.680
"我明白了。明白了。因此，我们已经
在

00:05:24.680 --> 00:05:29.600
此视图控制器，我已经
订阅，但从不取消订阅。

00:05:29.600 --> 00:05:31.970
所以它总是有这个
立即引用。

00:05:31.970 --> 00:05:34.940
所以垃圾收集者说，
"嘿，有什么可用的吗？

00:05:34.940 --> 00:05:37.030
它说，"你不能有。

00:05:37.030 --> 00:05:38.205
* 这是正确的。

00:05:38.205 --> 00:05:40.580
• 我想确保
这是正确的，因为我

00:05:40.580 --> 00:05:42.185
相信这是如何
它在我的脑海里工作。

00:05:42.185 --> 00:05:43.150
我想确定我是对的。

00:05:43.150 --> 00:05:47.225
• 单个任务垃圾回收器
做是去分配内存，

00:05:47.225 --> 00:05:48.605
并正确地做到这一点，

00:05:48.605 --> 00:05:50.540
垃圾收集器应该知道如何

00:05:50.540 --> 00:05:52.730
正确识别是否
是垃圾还是垃圾

00:05:52.730 --> 00:05:53.180
# 拿到了.

00:05:53.180 --> 00:05:55.790
• 因此，要构建一个可伸近的树，

00:05:55.790 --> 00:05:59.270
垃圾回收器
使用静态路由或

00:05:59.270 --> 00:06:01.430
只是路由和静态事件

00:06:01.430 --> 00:06:03.500
或任何静态属性
作为路线之一。

00:06:03.500 --> 00:06:06.460
也是局部变量，
很多其他的东西。

00:06:06.460 --> 00:06:07.020
# 拿到了.

00:06:07.020 --> 00:06:11.820
• 所以让我运行它
并展示它是如何工作的。

00:06:11.820 --> 00:06:14.745
你认为我们会
看到有什么不同了吗？

00:06:14.745 --> 00:06:17.540
我不知道我的意思是
希望不是因为

00:06:17.540 --> 00:06:20.090
它是如此简单，我的想法。

00:06:20.090 --> 00:06:22.160
现在，我的恐惧是

00:06:22.160 --> 00:06:24.200
因为我们注册了
一遍又一遍，

00:06:24.200 --> 00:06:26.750
如果我们改变事件

00:06:26.750 --> 00:06:28.850
我们可能得到
在很多事件中

00:06:28.850 --> 00:06:30.635
* 是的。让我们来验证一下。

00:06:30.635 --> 00:06:33.560
因此，我已移动到"详细信息"页面。

00:06:33.560 --> 00:06:36.185
我现在要断开我的 Wi-Fi 连接。

00:06:36.185 --> 00:06:38.510
• 在这里，我们使用
iOS 模拟器。

00:06:38.510 --> 00:06:41.975
因此，它实际上使用
机器的互联网。

00:06:41.975 --> 00:06:46.460
* 是。我们刚来参加一个活动
是连接更改。

00:06:46.460 --> 00:06:51.910
我们回去几次
再来几次

00:06:51.910 --> 00:06:54.630
我又回到了主页上

00:06:54.630 --> 00:06:58.215
我不细腻
任何现在，

00:06:58.215 --> 00:07:01.280
我猜想我的细节
页面不再存在，对不对？

00:07:01.280 --> 00:07:01.430
* 是的。

00:07:01.430 --> 00:07:02.810
• 我的订阅处理程序

00:07:02.810 --> 00:07:04.805
不应该工作，因为
我什么都没做。

00:07:04.805 --> 00:07:07.015
让我们打开 Wi-Fi。

00:07:07.015 --> 00:07:09.510
"好的。因此，我们实际上创造了

00:07:09.510 --> 00:07:11.910
此连接更改
在第二页。

00:07:11.910 --> 00:07:12.420
[ 第二页。

00:07:12.420 --> 00:07:13.665
"嗯，我在第一页。

00:07:13.665 --> 00:07:17.440
* 是。因此，我们不希望
我们的处理程序工作，

00:07:17.440 --> 00:07:18.645
但看看我们得到了什么

00:07:18.645 --> 00:07:21.090
我们只有四个处理程序
运行我们的代码，

00:07:21.090 --> 00:07:23.600
它可能是任何
代码更新数据库，

00:07:23.600 --> 00:07:25.505
保存设置，无论什么。

00:07:25.505 --> 00:07:28.070
这里的问题不仅
与内存管理

00:07:28.070 --> 00:07:30.635
因为它确实需要一些记忆。

00:07:30.635 --> 00:07:34.970
这也是一个问题，因为我们有
一些代码也执行。

00:07:34.970 --> 00:07:37.445
* 然后，这意味着
"详细信息"页，

00:07:37.445 --> 00:07:39.350
现在它永远不会
垃圾收集？

00:07:39.350 --> 00:07:42.455
所以现在我只是有这个
详细信息页面始终在内存中。

00:07:42.455 --> 00:07:43.400
[ ] 不幸的是，是的。

00:07:43.400 --> 00:07:44.660
哦，我的天哪，那太糟糕了。

00:07:44.660 --> 00:07:47.385
太糟糕了作为开发人员，

00:07:47.385 --> 00:07:49.560
我们并不总是看到这一点。

00:07:49.560 --> 00:07:54.280
作为用户，我看到我的应用崩溃
像每周一次，不管怎样。

00:07:54.280 --> 00:07:56.675
我只需重新启动它
并继续使用它。

00:07:56.675 --> 00:07:58.220
这就是为什么它不报告，

00:07:58.220 --> 00:08:00.350
它不是被认真对待，

00:08:00.350 --> 00:08:03.950
但这是一个问题，特别是如果你

00:08:03.950 --> 00:08:08.330
得到一个巨大的图像有
影响你的记忆

00:08:08.330 --> 00:08:10.910
所以我要取消评论
这行代码，

00:08:10.910 --> 00:08:14.680
这实际上增加了一些内存负载

00:08:14.680 --> 00:08:19.740
在这里，它正在加载
图片从互联网。

00:08:19.740 --> 00:08:22.265
我们只是随机拍摄一个图像。

00:08:22.265 --> 00:08:24.815
让我表明，这是真正的随机。

00:08:24.815 --> 00:08:27.035
让我们看看我们在这里得到了什么。

00:08:27.035 --> 00:08:29.510
我一直很担心

00:08:29.510 --> 00:08:32.210
好。所以我们有这个随机的图像，

00:08:32.210 --> 00:08:34.370
这就是我们
要加载

00:08:34.370 --> 00:08:37.190
我们的应用程序每次我们
进入详细信息页面。

00:08:37.190 --> 00:08:37.610
"好的。

00:08:37.610 --> 00:08:40.395
• 让我在这里展示它。

00:08:40.395 --> 00:08:42.970
* 这完全是东西
总是这样，对吧？

00:08:42.970 --> 00:08:45.220
因为转到"详细信息"页面，

00:08:45.220 --> 00:08:46.740
可能加载一些信息，

00:08:46.740 --> 00:08:48.080
可能是拉一些
信息来自

00:08:48.080 --> 00:08:51.095
屏幕上的数据库
那可能很糟

00:08:51.095 --> 00:08:53.930
• 想象你自己
使用 Instagram 应用程序。

00:08:53.930 --> 00:08:55.330
您有一个详细信息页面。

00:08:55.330 --> 00:08:56.710
你点击并跟随，

00:08:56.710 --> 00:08:58.435
进入细节，回去。

00:08:58.435 --> 00:09:00.720
去检查另一个文件夹，
细节，

00:09:00.720 --> 00:09:03.920
回去，并在一个星期内你的应用程序
崩溃，没有人知道为什么。

00:09:03.920 --> 00:09:06.680
这是当内存问题
可以来发挥。

00:09:06.680 --> 00:09:09.180
#找到你。

00:09:09.180 --> 00:09:11.855
我不会告诉你
内存泄漏仍然存在

00:09:11.855 --> 00:09:14.650
因为我想展示
你这个探查器，

00:09:14.650 --> 00:09:16.375
如何识别这些问题。

00:09:16.375 --> 00:09:17.800
要确定这些问题，

00:09:17.800 --> 00:09:19.990
你有几个工具。

00:09:19.990 --> 00:09:23.350
首先，它是原生工具，
iO 提供仪器，

00:09:23.350 --> 00:09:25.520
第二个是管理工具，

00:09:25.520 --> 00:09:27.005
这是萨马林探查器。

00:09:27.005 --> 00:09:27.990
#找到你。

00:09:27.990 --> 00:09:29.520
• 为什么你认为我们需要两者？

00:09:29.520 --> 00:09:32.985
他们做不同的事情。

00:09:32.985 --> 00:09:36.090
* 是的。实际上
因为这个图像。

00:09:36.090 --> 00:09:38.025
记得。我说的是那个

00:09:38.025 --> 00:09:41.565
他们实际上能知道
关于它自己的部分。

00:09:41.565 --> 00:09:44.190
所以萨马林探查员什么都不知道

00:09:44.190 --> 00:09:47.100
关于内存本机
在那里创建的对象，

00:09:47.100 --> 00:09:50.010
和本地仪器不
了解托管内存。

00:09:50.010 --> 00:09:52.685
它只是说有一些
块创建的对象。

00:09:52.685 --> 00:09:54.710
当单声道创建对象时，

00:09:54.710 --> 00:09:57.275
它仍然绑定它不知何故
到本机对象。

00:09:57.275 --> 00:09:59.210
所以那些你能看到的人，

00:09:59.210 --> 00:10:00.500
但剩下的不会

00:10:00.500 --> 00:10:01.220
"好的。酷。

00:10:01.220 --> 00:10:02.945
* 因此，让我们来看看Xamarin探查器。

00:10:02.945 --> 00:10:06.550
更容易理解
一开始

00:10:06.550 --> 00:10:10.955
它也显示你很好
命名空间，喜欢命名。

00:10:10.955 --> 00:10:12.815
因此，您可以识别对象。

00:10:12.815 --> 00:10:16.715
有一个小按钮"运行"
和"开始配置文件"在这里。

00:10:16.715 --> 00:10:20.050
您需要一个企业
许可做到这一点。

00:10:20.050 --> 00:10:23.870
但它非常方便，
我鼓励你这样做。

00:10:23.870 --> 00:10:25.190
所以一旦你这样做

00:10:25.190 --> 00:10:26.825
它实际上建立应用程序

00:10:26.825 --> 00:10:31.130
一些额外的元数据和
嵌入到应用中的代码。

00:10:31.130 --> 00:10:33.580
因此，我们可以看到和
跟踪对象。

00:10:33.580 --> 00:10:36.140
* 现在有一件事，而这
正在构建和部署

00:10:36.140 --> 00:10:38.030
我们运行在
模拟器，这意味着它

00:10:38.030 --> 00:10:40.520
有这个全马力。

00:10:40.520 --> 00:10:45.320
我这样做可以吗？
并在我的设备上分析它，

00:10:45.320 --> 00:10:49.150
还是最好在
物理iPhone，例如？

00:10:49.150 --> 00:10:50.570
这是一个很好的问题，因为你

00:10:50.570 --> 00:10:52.340
可以执行不同类型的分析。

00:10:52.340 --> 00:10:52.940
* 有趣。

00:10:52.940 --> 00:10:54.230
• 如果要分析 CPU，

00:10:54.230 --> 00:10:56.480
这不是个好主意
在模拟器上做

00:10:56.480 --> 00:10:58.820
因为你没有
设备的全部功率。

00:10:58.820 --> 00:11:01.340
但是，如果你正在做一个记忆
探查器和分配，

00:11:01.340 --> 00:11:04.355
你会得到同样的问题
在模拟器和设备上。

00:11:04.355 --> 00:11:04.730
• 完美。

00:11:04.730 --> 00:11:10.300
• 我喜欢在笔记本电脑上做
因为它开始得更快。

00:11:10.300 --> 00:11:13.010
它不翻译代码

00:11:13.010 --> 00:11:16.085
到本地指令，只是
立即模拟和运行。

00:11:16.085 --> 00:11:18.470
因此，每当您执行内存分析时，

00:11:18.470 --> 00:11:20.180
如果你运行应用程序这么多次，

00:11:20.180 --> 00:11:23.045
所以你会喜欢的

00:11:23.045 --> 00:11:25.085
让我做同样的测试。

00:11:25.085 --> 00:11:27.980
所以我打开了"详细信息"页面一次

00:11:27.980 --> 00:11:29.840
你看到这个小峰在这里。

00:11:29.840 --> 00:11:33.590
这意味着我们增加了我们的
内存使用显著。

00:11:33.590 --> 00:11:35.915
但你看不到这个
内存增加在这里。

00:11:35.915 --> 00:11:38.510
它仍然像最大的对象是

00:11:38.510 --> 00:11:40.730
系统树和某处在这里。

00:11:40.730 --> 00:11:43.155
让我再做几次。

00:11:43.155 --> 00:11:45.815
我会再增加一次。

00:11:45.815 --> 00:11:47.610
你会看到这里的尖峰，

00:11:47.610 --> 00:11:49.735
但你在这里看不到任何尖峰

00:11:49.735 --> 00:11:53.330
这意味着，当我们分配
在原生记忆中，

00:11:53.330 --> 00:11:56.220
它不反映
它在管理的世界，

00:11:56.220 --> 00:11:59.419
但我们看到总内存是
增长，而不是去分配，

00:11:59.419 --> 00:12:00.720
这是最重要的事情。

00:12:00.720 --> 00:12:01.455
"我明白了。

00:12:01.455 --> 00:12:04.015
• 我们带着此快照回来。

00:12:04.015 --> 00:12:05.710
内存快照实际运行

00:12:05.710 --> 00:12:07.875
垃圾收集
在托管站点上。

00:12:07.875 --> 00:12:10.195
因此，我们执行此快照。
我再做一次。

00:12:10.195 --> 00:12:11.755
我稍后再解释

00:12:11.755 --> 00:12:14.500
来处理终结提示。

00:12:14.500 --> 00:12:17.475
但基本上，现在是干净的内存。

00:12:17.475 --> 00:12:19.605
我们会确保
我们的垃圾收集器

00:12:19.605 --> 00:12:22.270
已经运行和交易
所有获取的对象。

00:12:22.270 --> 00:12:23.920
我们仍然看到那里的记忆。

00:12:23.920 --> 00:12:25.845
因此，它仍然下降。

00:12:25.845 --> 00:12:28.755
想知道这里发生了什么

00:12:28.755 --> 00:12:32.005
我们只是在这里
使用筛选器按钮。

00:12:32.005 --> 00:12:35.265
我们试图确定
只有 R 对象，

00:12:35.265 --> 00:12:38.110
我也想看到
现场对象在这里。

00:12:38.110 --> 00:12:40.980
所以我打这个"应用"
按钮，瞧，

00:12:40.980 --> 00:12:43.575
我们看到两个细节控制器
挂在记忆中，

00:12:43.575 --> 00:12:47.160
即使我不
有细节到位。

00:12:47.160 --> 00:12:48.570
• 超级样品，所以你说，

00:12:48.570 --> 00:12:50.289
在我的名字空间里找到一切

00:12:50.289 --> 00:12:51.610
过滤下来。

00:12:51.610 --> 00:12:54.820
字面上，我们在这里看到
是详细视图控制器 2。

00:12:54.820 --> 00:12:55.225
* 是的。

00:12:55.225 --> 00:12:56.650
* 但它应该消失。

00:12:56.650 --> 00:13:00.015
• 我将从最大的开始
对象在这些页面中。

00:13:00.015 --> 00:13:00.280
* 是的。

00:13:00.280 --> 00:13:02.865
* 这是真正的Android以及。

00:13:02.865 --> 00:13:04.030
你只是搜索活动

00:13:04.030 --> 00:13:05.395
查看模型，或者什么，

00:13:05.395 --> 00:13:07.875
因为一旦你有一个视图
模型挂在那里，

00:13:07.875 --> 00:13:11.320
它开始链接所有
其他对象。

00:13:11.320 --> 00:13:13.380
所有服务，所有绑定，

00:13:13.380 --> 00:13:16.605
所有的UIs，你会
获得大量的内存。

00:13:16.605 --> 00:13:17.500
# 拿到了.

00:13:17.500 --> 00:13:19.465
让我表明这是真的。

00:13:19.465 --> 00:13:23.260
我会再打开一个
时间，点击"快照"。

00:13:23.260 --> 00:13:25.455
我们在这里看到三个实例。

00:13:25.455 --> 00:13:28.569
我回去，打"快照"

00:13:28.569 --> 00:13:30.030
它留在记忆中。

00:13:30.030 --> 00:13:30.660
#找到你。

00:13:30.660 --> 00:13:32.500
• 因此，让我们修复此内存问题。

00:13:32.500 --> 00:13:33.700
"我准备好了

00:13:33.700 --> 00:13:36.470
• 您如何修复它？

00:13:41.220 --> 00:13:43.525
这是一个详细信息页面，

00:13:43.525 --> 00:13:45.460
所以我们需要取消订阅
在某些事件。

00:13:45.460 --> 00:13:49.325
#找到你。所以这里真正的问题
是我已经订阅了一个事件。

00:13:49.325 --> 00:13:49.970
* 是。

00:13:49.970 --> 00:13:52.135
• 然后我们应该取消订阅，对吗？

00:13:52.135 --> 00:13:54.550
* 这是正确的。这
是个好做法。

00:13:54.550 --> 00:13:56.370
每当你看到这个加等于，

00:13:56.370 --> 00:13:59.490
你只是搜索如果
有一个负相等，

00:13:59.490 --> 00:14:01.980
如果不是，你
应该介绍。

00:14:01.980 --> 00:14:02.595
# 拿到了.

00:14:02.595 --> 00:14:05.020
* 这是第一个指示
您有内存泄漏。

00:14:05.020 --> 00:14:05.340
# 拿到了.

00:14:05.340 --> 00:14:10.460
• 唯一的例外是
你在主页上订阅，

00:14:10.460 --> 00:14:12.285
就像我们的主页一样

00:14:12.285 --> 00:14:14.725
你确信这个页面

00:14:14.725 --> 00:14:18.010
不能去
离开很快。

00:14:18.010 --> 00:14:20.115
• 也许你有它
应用委托级别。

00:14:20.115 --> 00:14:21.530
你就像，我其实
希望这是

00:14:21.530 --> 00:14:23.290
一个全球性的事件。

00:14:23.290 --> 00:14:25.845
但也可能是当你的应用程序
进入背景，

00:14:25.845 --> 00:14:27.295
您还应取消订阅。

00:14:27.295 --> 00:14:28.345
* 确实如此。

00:14:28.345 --> 00:14:28.675
* 是的。

00:14:28.675 --> 00:14:29.700
* 不执行。

00:14:29.700 --> 00:14:31.750
现在你说
当它出现时，

00:14:31.750 --> 00:14:33.855
它会订阅，并消失，

00:14:33.855 --> 00:14:35.935
取消订阅，然后你
删除顶部。

00:14:35.935 --> 00:14:37.990
• 是，我从云中删除，

00:14:37.990 --> 00:14:39.710
因为我们想
每次我们运行它

00:14:39.710 --> 00:14:42.040
出现，每次我们消失。

00:14:42.040 --> 00:14:43.850
加上等于订阅，

00:14:43.850 --> 00:14:45.640
减等于取消订阅。

00:14:45.640 --> 00:14:48.735
没什么复杂的，只是想

00:14:48.735 --> 00:14:52.045
确保我们不需要任何
仪器，一旦你通过它。

00:14:52.045 --> 00:14:52.720
• 冷却。

00:14:52.720 --> 00:14:55.110
所以我在做同样的事情

00:14:55.110 --> 00:14:59.490
细节，
表明这是真的。

00:14:59.490 --> 00:15:02.980
拍摄快照，
过滤到我的事件。

00:15:02.980 --> 00:15:05.300
对不起。它只是点击。

00:15:08.700 --> 00:15:12.170
让我们看看活的对象。

00:15:12.420 --> 00:15:15.345
我们应该看看细节
因为我们目前在

00:15:15.345 --> 00:15:17.475
详细信息页面。我们要回去了

00:15:17.475 --> 00:15:18.990
我们打了一个"快照"

00:15:18.990 --> 00:15:20.880
我们在这里期待什么？

00:15:20.880 --> 00:15:23.715
首先，垃圾回收实际上

00:15:23.715 --> 00:15:26.065
将这些对象放入
终结提示，

00:15:26.065 --> 00:15:27.625
但第二提示1，

00:15:27.625 --> 00:15:30.340
或者可能还是同一个

00:15:30.340 --> 00:15:31.570
现在它不见了。

00:15:31.570 --> 00:15:33.910
* 是。让我来谈谈

00:15:33.910 --> 00:15:36.940
在
第二，但现在，

00:15:36.940 --> 00:15:40.395
这个想法是，我们已经
失去了我们的细节视图，

00:15:40.395 --> 00:15:43.135
和我们的记忆使用量下降。

00:15:43.135 --> 00:15:43.770
* 美丽。

00:15:43.770 --> 00:15:46.150
• 这就是我们修复内存泄漏的方式。

00:15:46.150 --> 00:15:49.420
* 是的。您订阅了您的
事件。取消订阅事件。

00:15:49.420 --> 00:15:51.630
• 基本经验法则。

00:15:51.630 --> 00:15:54.915
那也很有趣
因为一，它导致两个问题。

00:15:54.915 --> 00:15:56.800
我们看到你让它活着

00:15:56.800 --> 00:15:58.750
因为这些事件会一直持续

00:15:58.750 --> 00:16:00.715
所以现在你开火了
他们多次，

00:16:00.715 --> 00:16:04.290
而且，任何在那个页面上
将被留在记忆中

00:16:04.290 --> 00:16:06.685
"没错"所以
我们添加了一个沉重的图像，

00:16:06.685 --> 00:16:08.205
它仍然在记忆中。

00:16:08.205 --> 00:16:08.830
# 拿到了.

00:16:08.830 --> 00:16:10.570
• 让我向您展示乐器。

00:16:10.570 --> 00:16:13.390
所以我要介绍
回到我们的记忆泄漏。

00:16:13.390 --> 00:16:13.800
* 当然可以。

00:16:13.800 --> 00:16:15.985
• 只需删除取消订阅事件。

00:16:15.985 --> 00:16:18.435
我要部署到我的模拟器

00:16:18.435 --> 00:16:21.330
和仪器工作相当容易。

00:16:21.330 --> 00:16:23.355
你只需从

00:16:23.355 --> 00:16:25.930
模拟器和
应用程序，这就是它。

00:16:25.930 --> 00:16:28.435
这就是你需要开始的所有
仪器探查器。

00:16:28.435 --> 00:16:30.175
即使它是萨马林应用程序，

00:16:30.175 --> 00:16:32.150
你可以开始它的权利
从仪器，

00:16:32.150 --> 00:16:33.615
对萨马林一无所知

00:16:33.615 --> 00:16:35.310
• 仪器从何而来？

00:16:35.310 --> 00:16:38.709
• 苹果。是苹果
工具，附带 Xcode，

00:16:38.709 --> 00:16:41.950
它有很多
工具在里面。

00:16:41.950 --> 00:16:43.450
* 所以它只是内置
因为你已经有了

00:16:43.450 --> 00:16:45.415
已安装 Xcode？所以
每个人都有这个吗？

00:16:45.415 --> 00:16:46.015
• 免费。

00:16:46.015 --> 00:16:48.925
• 免费。酷。所以任何人
今天能用这个吗？

00:16:48.925 --> 00:16:53.880
* 是。实际上，您可以
看到这些活动，

00:16:53.880 --> 00:16:57.920
即使那些由托管创建
世界喜欢细节活动，

00:16:57.920 --> 00:17:00.525
它仍然表示
由本机对象。

00:17:00.525 --> 00:17:00.930
# 拿到了.

00:17:00.930 --> 00:17:02.855
• 因此，让我们寻找该对象。

00:17:02.855 --> 00:17:07.240
我们称之为详细信息视图控制器。

00:17:07.240 --> 00:17:09.595
让我创建其中的几个。

00:17:09.595 --> 00:17:11.030
* 这实际上是
真的很酷，因为

00:17:11.030 --> 00:17:12.240
我从没用过乐器

00:17:12.240 --> 00:17:15.295
多年不告诉任何人

00:17:15.295 --> 00:17:18.440
我不认为每个人都在给予
我一个细节。所以它存在？

00:17:18.440 --> 00:17:20.070
• 是的，它存在。

00:17:20.070 --> 00:17:22.335
* 这是有道理的
因为萨马林是土生土长的

00:17:22.335 --> 00:17:23.770
因此，它创建了一个本机对象。

00:17:23.770 --> 00:17:26.380
* 是。你不需要做

00:17:26.380 --> 00:17:27.885
此处的内存快照

00:17:27.885 --> 00:17:29.975
因为我们没有
垃圾收集在这里。

00:17:29.975 --> 00:17:33.780
IOS 使用层次结构，即
自动参考计数器。

00:17:33.780 --> 00:17:35.605
基本上，每当
创建对象，

00:17:35.605 --> 00:17:37.065
它递增计数器，

00:17:37.065 --> 00:17:39.550
任何时候，你不使用或它

00:17:39.550 --> 00:17:42.505
远离范围
使用，它递减计数器。

00:17:42.505 --> 00:17:43.845
一旦计数器为零，

00:17:43.845 --> 00:17:46.495
对象是垃圾，
它可以被收集。

00:17:46.495 --> 00:17:48.075
因此，这是相当容易开始

00:17:48.075 --> 00:17:51.735
仪器与应用程序
只需单击此按钮即可。

00:17:51.735 --> 00:17:53.505
它启动应用程序，

00:17:53.505 --> 00:17:55.860
它显示了此处的内存使用情况。

00:17:55.860 --> 00:17:57.690
让我们打开"详细信息"页面。

00:17:57.690 --> 00:18:00.425
#找到你。仪器
来自苹果？

00:18:00.425 --> 00:18:02.040
• 仪器来自苹果。

00:18:02.040 --> 00:18:03.350
这是苹果的免费工具。

00:18:03.350 --> 00:18:04.490
您可以立即使用。

00:18:04.490 --> 00:18:05.390
• 冷却。

00:18:05.390 --> 00:18:06.970
* 你看，我们也有

00:18:06.970 --> 00:18:10.140
此内存占用右
在这里，一旦我们打开详细信息页面。

00:18:10.140 --> 00:18:12.120
让我们再打开一次。

00:18:12.120 --> 00:18:15.140
* 所以这是非常相似
到Xamarin探查器，

00:18:15.140 --> 00:18:16.870
但这将向我们展示

00:18:16.870 --> 00:18:19.240
所有本机堆栈
意图和目的。

00:18:19.240 --> 00:18:21.500
"没错"不幸的是，它

00:18:21.500 --> 00:18:24.090
不知道什么
萨马林和管理世界，

00:18:24.090 --> 00:18:27.025
所以你将看不到
它创建的托管对象。

00:18:27.025 --> 00:18:28.990
所以你看到尖峰，

00:18:28.990 --> 00:18:30.850
你看它不会消失。

00:18:30.850 --> 00:18:33.350
让我再做一次

00:18:33.350 --> 00:18:35.145
并只显示对象。

00:18:35.145 --> 00:18:38.455
让我们看看。有
一个小的过滤器按钮。

00:18:38.455 --> 00:18:43.170
我们转到此处的所有分配，

00:18:43.170 --> 00:18:45.165
并击中"细节"。

00:18:45.165 --> 00:18:45.820
"好的。

00:18:45.820 --> 00:18:47.555
* 这是三页在这里，

00:18:47.555 --> 00:18:48.660
他们都在记忆中

00:18:48.660 --> 00:18:50.650
并在内存中分配。

00:18:50.650 --> 00:18:54.070
我不会展示我们如何分配
因为它是相同的修复，

00:18:54.070 --> 00:18:57.020
我们只是取消订阅，
托管世界取消订阅

00:18:57.020 --> 00:19:00.120
从对象。对象
被认为是垃圾。

00:19:00.120 --> 00:19:04.660
然后我们的垃圾收集器
收集这些信息，

00:19:04.660 --> 00:19:06.460
然后本地可以收集
因为没什么

00:19:06.460 --> 00:19:08.490
从管理世界
已经持有。

00:19:08.490 --> 00:19:10.780
[ ] 有意义。所以非常
大致相同的修复，

00:19:10.780 --> 00:19:12.255
而是另一种检测方式

00:19:12.255 --> 00:19:15.045
"没错"所以这是

00:19:15.045 --> 00:19:19.345
关于之间的差异
管理和本地世界。

00:19:19.345 --> 00:19:22.120
我的下一个示例将
主要是关于管理

00:19:22.120 --> 00:19:25.320
世界，因为你可以
在任何中引入问题，

00:19:25.320 --> 00:19:26.905
和萨马林无关

00:19:26.905 --> 00:19:29.570
就像你说的，它可能是
订阅静态事件，

00:19:29.570 --> 00:19:32.745
它可以引入
问题，甚至任何地方。

00:19:32.745 --> 00:19:35.410
所以接下来的事情是

00:19:35.410 --> 00:19:38.210
关于订阅，以及
没有取消订阅。

00:19:38.210 --> 00:19:39.315
但在这种情况下

00:19:39.315 --> 00:19:42.820
我们实际上是
隐式订阅，

00:19:42.820 --> 00:19:44.480
我们不使用加等于。

00:19:44.480 --> 00:19:46.015
因此，很难找到。

00:19:46.015 --> 00:19:48.710
在这种情况下，我们运行
通知中心尝试

00:19:48.710 --> 00:19:51.795
识别每当我们的应用程序旋转。

00:19:51.795 --> 00:19:53.695
我们在此观察员中添加。

00:19:53.695 --> 00:19:57.525
这是一个单例默认中心。

00:19:57.525 --> 00:19:59.700
我们说，我想得到

00:19:59.700 --> 00:20:02.595
任何信息，每当
方向改变，

00:20:02.595 --> 00:20:04.140
这里是我的处理程序。

00:20:04.140 --> 00:20:04.650
# 拿到了.

00:20:04.650 --> 00:20:06.690
• 处理程序本身，
相当容易

00:20:06.690 --> 00:20:08.125
我们什么都不会做

00:20:08.125 --> 00:20:11.665
我们只是打印出来进行调试。

00:20:11.665 --> 00:20:12.465
# 拿到了.

00:20:12.465 --> 00:20:15.525
• 让我删除
连接的东西，因为

00:20:15.525 --> 00:20:18.630
我们想介绍不同的
内存问题。

00:20:18.630 --> 00:20:21.525
我也评论出我们的
图像，因为我们不需要

00:20:21.525 --> 00:20:24.430
显示内存
脚印，它在那里。

00:20:24.430 --> 00:20:28.390
我们将尝试
UI 视图控制器和视图。

00:20:28.390 --> 00:20:30.650
• 非常酷。所以这
非常相似，

00:20:30.650 --> 00:20:32.870
但这种模式，你
可以订阅，

00:20:32.870 --> 00:20:34.605
甚至可能通过一个行动。

00:20:34.605 --> 00:20:38.340
或在这种情况下，它的作用
上面写着这是你的回叫。

00:20:38.340 --> 00:20:40.010
代表非常相似，

00:20:40.010 --> 00:20:41.115
我认为这种模式。

00:20:41.115 --> 00:20:42.480
所以这只是一些
我也习惯了。

00:20:42.480 --> 00:20:45.590
"没错"那是

00:20:45.590 --> 00:20:47.864
他们的主要想法，因为
当你订阅时，

00:20:47.864 --> 00:20:51.405
你传递的引用
UI 视图控制器。

00:20:51.405 --> 00:20:53.425
这只是一个不同的
传递引用的方法。

00:20:53.425 --> 00:20:55.260
有时候就不太明显了。

00:20:55.260 --> 00:20:57.955
因此，我们有我们的订阅，
它在这里运行。

00:20:57.955 --> 00:20:59.305
它只运行一次。

00:20:59.305 --> 00:21:01.780
让我们关闭并再次打开它。

00:21:01.780 --> 00:21:03.525
现在，我们有一个双击。

00:21:03.525 --> 00:21:05.230
让我明确地告诉你这个。

00:21:05.230 --> 00:21:07.240
旋转一次，得到两个，

00:21:07.240 --> 00:21:11.655
这意味着我们有一些用户界面视图
控制器挂在内存中，

00:21:11.655 --> 00:21:13.535
同时仍然处理第一个。

00:21:13.535 --> 00:21:13.980
# 拿到了.

00:21:13.980 --> 00:21:15.430
• 如果您有

00:21:15.430 --> 00:21:19.660
一些数据库更新逻辑
或 HTTP 请求加班。

00:21:19.660 --> 00:21:21.340
就像在使用一天，

00:21:21.340 --> 00:21:24.810
你的应用没有被杀死，你
停用，重新激活。

00:21:24.810 --> 00:21:26.740
它将拥有这一切
查看仍在内存中，

00:21:26.740 --> 00:21:28.265
一周后，它可能会崩溃。

00:21:28.265 --> 00:21:28.785
* 是的。

00:21:28.785 --> 00:21:30.105
• 那么如何修复它呢？

00:21:30.105 --> 00:21:31.550
这很容易。

00:21:31.550 --> 00:21:34.145
• 假定您取消订阅？

00:21:34.145 --> 00:21:35.835
"没错"这更难

00:21:35.835 --> 00:21:38.685
取消订阅，因为您
没有加等于。

00:21:38.685 --> 00:21:42.010
让我也展示你
实际上发送到这里。

00:21:42.010 --> 00:21:43.365
所以当你订阅时，

00:21:43.365 --> 00:21:46.395
您传递了方法名称。

00:21:46.395 --> 00:21:48.215
你实际上是在通过一个动作

00:21:48.215 --> 00:21:51.745
编译器正在执行
隐藏它的伟大工作，

00:21:51.745 --> 00:21:54.150
让我们的生活更轻松

00:21:54.150 --> 00:21:55.945
• 编译器非常好。

00:21:55.945 --> 00:21:57.255
我们很好。

00:21:57.255 --> 00:22:00.415
这就是为什么我们喜欢成为开发人员的原因。

00:22:00.415 --> 00:22:04.360
因此，它实际上要求
使用 NS 通知的操作。

00:22:04.360 --> 00:22:07.840
所以我在这里签署NS通知，

00:22:07.840 --> 00:22:13.365
然后用这个记号法，
粘贴此对象。

00:22:13.365 --> 00:22:16.560
因此，而不是方法名称，

00:22:16.560 --> 00:22:19.225
我们实际上通过
一个动作和对象，

00:22:19.225 --> 00:22:20.960
持有引用

00:22:20.960 --> 00:22:23.610
这些元数据如何
调用 方法。

00:22:23.610 --> 00:22:26.555
所以我们不传递方法
只是个参考

00:22:26.555 --> 00:22:30.060
在我们的例子中，最重要的
传递此引用时的一部分，

00:22:30.060 --> 00:22:32.155
这是UIV控制器，

00:22:32.155 --> 00:22:34.170
这就是为什么它被留在记忆中。

00:22:34.170 --> 00:22:35.260
# 拿到了.

00:22:35.260 --> 00:22:35.865
"好的。

00:22:35.865 --> 00:22:36.670
[ ] 有意义。是的。

00:22:36.670 --> 00:22:38.595
• 我不会显示详细信息

00:22:38.595 --> 00:22:40.390
因为内存
泄漏仍然存在

00:22:40.390 --> 00:22:43.975
因为我们看到这些
事情，以节省一些时间。

00:22:43.975 --> 00:22:45.500
我想专注于

00:22:45.500 --> 00:22:48.830
最坏的情况
你应该知道。

00:22:48.830 --> 00:22:54.250
当本地世界不放置
与管理的世界很好。

00:22:54.250 --> 00:22:56.280
#找到你。当
两个世界相撞。

00:22:56.280 --> 00:23:00.265
* 这是正确的，因为每当
我们创建了托管对象，

00:23:00.265 --> 00:23:02.155
并且创建了一个本机对象，

00:23:02.155 --> 00:23:05.690
他/她试图
释放本机对象，

00:23:05.690 --> 00:23:07.495
我们的管理世界认为，

00:23:07.495 --> 00:23:09.330
我仍然没有完成这个对象。

00:23:09.330 --> 00:23:11.270
请坚持住，不要

00:23:11.270 --> 00:23:13.765
收集对象，因为
我还在用这个

00:23:13.765 --> 00:23:14.525
#找到你。

00:23:14.525 --> 00:23:15.805
• 可能正好相反，

00:23:15.805 --> 00:23:19.130
当一个本土世界
可以创建一个对象，

00:23:19.130 --> 00:23:20.265
现在一个管理的世界认为，

00:23:20.265 --> 00:23:22.450
它还没有完成，仍然
那里，所以让我们举行。

00:23:22.450 --> 00:23:25.015
即使你没有其他
对此对象的引用，

00:23:25.015 --> 00:23:29.015
它可以举行它，它可以
保持它而不是作为垃圾。

00:23:29.015 --> 00:23:29.820
#找到你。

00:23:29.820 --> 00:23:31.460
我可以用

00:23:31.460 --> 00:23:34.640
这些小图像
不朽的对象。

00:23:34.640 --> 00:23:37.230
所以不要创造不朽
对象。那些是坏的。

00:23:37.230 --> 00:23:38.435
• 听起来很酷。

00:23:38.435 --> 00:23:39.963
* 是的。

00:23:39.963 --> 00:23:43.355
它发生在你
有这两个世界。

00:23:43.355 --> 00:23:46.925
本机，您看到右侧
本机视图控制器和视图，

00:23:46.925 --> 00:23:49.640
从左边，你有

00:23:49.640 --> 00:23:52.580
管理世界 C 夏普谁是
查看控制器和视图。

00:23:52.580 --> 00:23:55.640
每当你不知道是什么
发生在本土世界，

00:23:55.640 --> 00:23:58.070
您不能收集
它来自这个世界。

00:23:58.070 --> 00:24:00.905
我给你举一个例子
你该如何做到这一点。

00:24:00.905 --> 00:24:03.275
所以在我的例子中，

00:24:03.275 --> 00:24:07.235
我想在这里添加一个小
小按钮"保存"，

00:24:07.235 --> 00:24:11.375
只是想关闭
查看用户点击后。

00:24:11.375 --> 00:24:13.925
让我们假设
"保存"按钮也将做

00:24:13.925 --> 00:24:17.330
一些保存的逻辑数据库
或 HTTP 调用任何内容，

00:24:17.330 --> 00:24:19.055
它只是不回去

00:24:19.055 --> 00:24:22.145
它实际上执行
一些额外的行动。

00:24:22.145 --> 00:24:22.775
"好的。

00:24:22.775 --> 00:24:24.980
* 作为这些按钮的详细信息，

00:24:24.980 --> 00:24:26.300
我们发送处理程序。

00:24:26.300 --> 00:24:31.205
这个处理程序说
请关闭这些控制器。

00:24:31.205 --> 00:24:33.395
• 看起来完全合法。

00:24:33.395 --> 00:24:35.255
* 是。我们将介绍
内存泄漏。

00:24:35.255 --> 00:24:36.230
"好的。

00:24:36.230 --> 00:24:42.515
你很坏很不幸
这是一个常见的模式。

00:24:42.515 --> 00:24:45.005
我们没有任何
静态事件，如下所示。

00:24:45.005 --> 00:24:47.195
我们没有
单音像这里。

00:24:47.195 --> 00:24:49.025
我们只是把这个按钮放在这儿

00:24:49.025 --> 00:24:51.650
这只是一个本地项目。

00:24:51.650 --> 00:24:54.260
好了，詹姆斯，现在我们
创建了一个按钮，并

00:24:54.260 --> 00:24:56.735
我们想把它添加到
我们的导航视图。

00:24:56.735 --> 00:25:00.440
因此，我们说，通过它
导航项也不使用

00:25:00.440 --> 00:25:05.225
任何静态引用没有
喜欢，只是它。

00:25:05.225 --> 00:25:08.015
现在我们有子按钮
让我们开始探查器。

00:25:08.015 --> 00:25:09.890
* 是，再次，
超级相似的模式。

00:25:09.890 --> 00:25:11.285
我创建一个按钮，

00:25:11.285 --> 00:25:15.800
添加一个按钮，然后我弹出
视图控制器似乎正常。

00:25:15.800 --> 00:25:18.185
• 具有不使用的委托

00:25:18.185 --> 00:25:20.540
任何外部或静态引用

00:25:20.540 --> 00:25:23.225
并且不传递任何引用
从我们的控制器。

00:25:23.225 --> 00:25:23.750
#找到你。

00:25:23.750 --> 00:25:27.090
• 应该工作正常，
对？我看看。

00:25:27.280 --> 00:25:32.780
因此，探查器将显示对象

00:25:32.780 --> 00:25:34.760
创建在最开始，我

00:25:34.760 --> 00:25:37.790
开始跟踪
他们在最开始。

00:25:37.790 --> 00:25:39.530
所以我有隐藏的快照的权利

00:25:39.530 --> 00:25:42.455
现在，并筛选到我的对象。

00:25:42.455 --> 00:25:45.380
再次是非常常见的
模式进行故障排除

00:25:45.380 --> 00:25:48.800
内存问题只是
只看到我的对象。

00:25:48.800 --> 00:25:52.235
那我就去了一次
这是我的按钮。

00:25:52.235 --> 00:25:55.565
你看，这是一个新的控件
很好，我们的应用程序。

00:25:55.565 --> 00:25:56.870
我们在记忆中有这个

00:25:56.870 --> 00:25:58.745
这是真的，我们期望。

00:25:58.745 --> 00:26:03.410
回去吧，我们打一个
更多的时间和一次。

00:26:03.410 --> 00:26:04.430
* 再来一次，因为我知道。

00:26:04.430 --> 00:26:05.195
• 再来一次。

00:26:05.195 --> 00:26:06.380
"好吧，还在那里。

00:26:06.380 --> 00:26:08.270
• 再一次，它仍然在那里。

00:26:08.270 --> 00:26:11.030
因此，让我们打开它，更多次。

00:26:11.030 --> 00:26:14.090
让我们也关闭它
以不同的方式回去，

00:26:14.090 --> 00:26:17.390
要保存，它实际上
基本上做同样的。

00:26:17.390 --> 00:26:20.090
让我们打"记忆"
快照"多一个

00:26:20.090 --> 00:26:22.610
时间和哦，哇，我们
有五个实例

00:26:22.610 --> 00:26:24.920
挂在那里的页面
内存，如果你有

00:26:24.920 --> 00:26:28.130
一个巨大的图像有它
会有很多的记忆

00:26:28.130 --> 00:26:28.550
# 拿到了.

00:26:28.550 --> 00:26:32.615
* 所以这是一个非常常见的模式

00:26:32.615 --> 00:26:36.800
因为它不明显，
你这儿有内存泄漏

00:26:36.800 --> 00:26:39.830
这里的问题是
该 UIbar 按钮项

00:26:39.830 --> 00:26:43.910
实际持有
一些本地资源，

00:26:43.910 --> 00:26:45.485
绑定到本机资源。

00:26:45.485 --> 00:26:49.100
如果我们不说清楚
我不再需要这个按钮

00:26:49.100 --> 00:26:51.020
您将介绍
这个不朽的对象。

00:26:51.020 --> 00:26:53.135
#找到你。那么，如何
我解决了这件事？

00:26:53.135 --> 00:26:56.240
• 为了解决这个问题，让我们使用

00:26:56.240 --> 00:26:59.900
我们的观点消失事件和
用我们的按钮做一些事情。

00:26:59.900 --> 00:27:00.150
"好的。

00:27:00.150 --> 00:27:01.220
* 所以我们有两个选择，

00:27:01.220 --> 00:27:02.735
我们可以使用

00:27:02.735 --> 00:27:05.299
已单击事件和
订阅和取消订阅，

00:27:05.299 --> 00:27:07.160
但我们会回到

00:27:07.160 --> 00:27:10.400
我们的第一个项目，当我们订阅
无需取消订阅。

00:27:10.400 --> 00:27:12.560
让我们做一些更有趣的事情。

00:27:12.560 --> 00:27:14.030
我们只需释放按钮。

00:27:14.030 --> 00:27:15.680
我喜欢这样。我
完成了，对不对？

00:27:15.680 --> 00:27:18.320
是的，我们有点说
管理世界，

00:27:18.320 --> 00:27:20.495
"我已经用按钮
请处置它。

00:27:20.495 --> 00:27:24.365
这不明显，因为
大量的视图和包装

00:27:24.365 --> 00:27:26.540
在萨马林 iOS 有
这种处置方法和

00:27:26.540 --> 00:27:29.015
你不知道每当
你应该打电话来

00:27:29.015 --> 00:27:30.815
因此，这是有趣的例子。

00:27:30.815 --> 00:27:32.975
但是，让我们这样做，让我们运行。

00:27:32.975 --> 00:27:34.700
这是我唯一添加的动作

00:27:34.700 --> 00:27:37.500
因为上一个应用程序运行。

00:27:38.290 --> 00:27:42.530
我正在启动探查器
并执行相同的用例。

00:27:42.530 --> 00:27:44.000
我们要跟踪对象从

00:27:44.000 --> 00:27:46.310
最开始，使
确保它们已处置。

00:27:46.310 --> 00:27:48.050
• 非常酷。这很好

00:27:48.050 --> 00:27:49.670
所以，你可以像你说的，

00:27:49.670 --> 00:27:53.270
而不是通过
整个行动，

00:27:53.270 --> 00:27:55.130
你可以像我们一样

00:27:55.130 --> 00:27:57.605
做连接，
订阅、取消订阅、

00:27:57.605 --> 00:28:00.590
我会想到的
出，但在这种情况下，

00:28:00.590 --> 00:28:03.125
你已经这样做了
你只是处置它。

00:28:03.125 --> 00:28:04.010
"没错"

00:28:04.010 --> 00:28:04.875
• 冷却。

00:28:04.875 --> 00:28:08.455
* 是的，因为我们没有
预期它将取消订阅。

00:28:08.455 --> 00:28:10.840
这不是订阅，

00:28:10.840 --> 00:28:14.230
我们只是通过和委托
局部对象内部。

00:28:14.230 --> 00:28:16.045
在通知中心的情况下，

00:28:16.045 --> 00:28:18.790
这是一种订阅，因为
我们传递本地对象

00:28:18.790 --> 00:28:21.760
成一些静态
实例或单例。

00:28:21.760 --> 00:28:24.760
在这种情况下，我们只是使用
在我们当地的资源中，

00:28:24.760 --> 00:28:26.395
我们不希望内存泄漏。

00:28:26.395 --> 00:28:26.680
#找到你。

00:28:26.680 --> 00:28:28.630
但很不幸，我能看见

00:28:28.630 --> 00:28:32.660
这个障碍很多和人
进入这些情况。

00:28:32.680 --> 00:28:37.530
因此，让我们做同样的把戏。

00:28:37.750 --> 00:28:41.760
我希望它能保存这些数据。

00:28:41.950 --> 00:28:46.310
因此，我们只有一个视图
控制器和委托。

00:28:46.310 --> 00:28:48.290
让我们点击"保存"。

00:28:48.290 --> 00:28:51.215
我们回去吧

00:28:51.215 --> 00:28:54.005
让我们实际停留在详细信息页面。

00:28:54.005 --> 00:28:56.975
点击"内存快照"，我们看到一个。

00:28:56.975 --> 00:28:59.315
让我再点击几次。

00:28:59.315 --> 00:29:02.735
我们来谈谈所以我们
这里只有一个实例。

00:29:02.735 --> 00:29:10.805
我单击"保存"，单击"快照"
它消失扫描。

00:29:10.805 --> 00:29:12.380
好？内存泄漏已修复。

00:29:12.380 --> 00:29:13.250
• 非常酷。好。

00:29:13.250 --> 00:29:14.900
• 不朽的对象被杀死。

00:29:14.900 --> 00:29:16.445
[ ] 已杀死。很酷

00:29:16.445 --> 00:29:17.810
否则，这是真棒。

00:29:17.810 --> 00:29:20.600
很简单，看看你的事件，

00:29:20.600 --> 00:29:22.850
也看看你是如何通过的

00:29:22.850 --> 00:29:24.890
这些行动周围，甚至我

00:29:24.890 --> 00:29:26.870
甚至不会想到
按钮对你诚实

00:29:26.870 --> 00:29:29.315
因为构造函数
正在传递这个东西

00:29:29.315 --> 00:29:29.600
* 是。

00:29:29.600 --> 00:29:30.725
* 非常酷。

00:29:30.725 --> 00:29:33.350
• 我还建议

00:29:33.350 --> 00:29:36.425
我们的开发人员使用它更多
经常喜欢一周一次，

00:29:36.425 --> 00:29:39.545
每个冲刺，然后到
查看内存使用情况，

00:29:39.545 --> 00:29:41.585
您可以将其视为 UI 测试运行。

00:29:41.585 --> 00:29:45.590
它显示了这个小
内存工作集。

00:29:45.590 --> 00:29:48.050
所以你只是看到
月，如果它的增长或

00:29:48.050 --> 00:29:51.530
不，如果它增长你
可能有内存泄漏。

00:29:51.530 --> 00:29:53.360
• 您展示了 iOS。

00:29:53.360 --> 00:29:54.560
现在，安卓呢？

00:29:54.560 --> 00:29:57.500
是否有任何其他特定
工具，你可以使用？

00:29:57.500 --> 00:29:59.465
这是一个很好的问题
因为，安卓，

00:29:59.465 --> 00:30:02.000
我们谈论的一切
iOS 适用于安卓系统。

00:30:02.000 --> 00:30:02.150
#找到你。

00:30:02.150 --> 00:30:03.440
* 只是有不同的工具

00:30:03.440 --> 00:30:07.145
安卓原生探查器
称为 Android 探查器。

00:30:07.145 --> 00:30:08.390
这真的很酷。

00:30:08.390 --> 00:30:09.740
它显示你很多

00:30:09.740 --> 00:30:12.380
信息，但你仍然
不得不使用它是谁

00:30:12.380 --> 00:30:14.330
Xamarin 探查器结合

00:30:14.330 --> 00:30:16.790
因为管理
世界和本土世界。

00:30:16.790 --> 00:30:17.930
#找到你。它只是它

00:30:17.930 --> 00:30:19.340
听起来很酷，
有伟大的工具

00:30:19.340 --> 00:30:22.400
可用，无论在哪里
你在，iOS，安卓。

00:30:22.400 --> 00:30:23.240
* 这是正确的。

00:30:23.240 --> 00:30:24.005
我可以继续做下去。

00:30:24.005 --> 00:30:25.820
老实说，只是看看
在其中一些，

00:30:25.820 --> 00:30:28.160
我很确定我的代码
有很多不好的东西

00:30:28.160 --> 00:30:29.480
所以当我流下一个，

00:30:29.480 --> 00:30:31.790
这将是所有
修复我的记忆泄漏

00:30:31.790 --> 00:30:32.180
"好的。

00:30:32.180 --> 00:30:34.280
• 非常酷。任何其他亚历克西
你想谈谈吗？

00:30:34.280 --> 00:30:35.315
* 这一切为今天。

00:30:35.315 --> 00:30:37.865
* 真棒。谢谢
每个人调谐。

00:30:37.865 --> 00:30:40.010
亚历克西，非常感谢你
显示所有这些东西。

00:30:40.010 --> 00:30:42.305
谢谢大家谢谢
你詹姆斯让我。

00:30:42.305 --> 00:30:43.970
* 绝对，并确保

00:30:43.970 --> 00:30:45.920
你检查出所有
下面的显示说明，

00:30:45.920 --> 00:30:47.420
打开所有源
代码，所有的链接

00:30:47.420 --> 00:30:48.980
所有文档在那里。

00:30:48.980 --> 00:30:51.740
您也可以去aka.ms/Xamarin

00:30:51.740 --> 00:30:54.485
整个系列的最佳实践。

00:30:54.485 --> 00:30:55.790
因此，请确保您订阅

00:30:55.790 --> 00:30:57.695
今天，无论你在哪里
看着现在。

00:30:57.695 --> 00:30:59.090
我是詹姆斯·蒙特马格诺

00:30:59.090 --> 00:31:01.790
这是萨马林
显示和感谢观看。

00:31:01.790 --> 00:31:02.480
谢谢大家

00:31:02.480 --> 00:31:09.230
[音乐]

00:31:09.230 --> 00:31:11.120
嘿，詹姆斯
只是想登记入住

00:31:11.120 --> 00:31:13.175
并感谢您
观看此视频。

00:31:13.175 --> 00:31:16.265
现在做所有的事情，你
知道你想做这样的，

00:31:16.265 --> 00:31:18.710
订阅，和丁
通知铃，

00:31:18.710 --> 00:31:20.825
成为的一部分
通知小队。

00:31:20.825 --> 00:31:22.190
当你在这里，看看

00:31:22.190 --> 00:31:25.400
所有这些真棒视频
我已经编码了

00:31:25.400 --> 00:31:29.040
点击那东西。点击
它，看着它，做它。