主页
Top.Mail.Ru Yandeks.Metrika
论坛:“其他”;
当前存档:2007.11.25;
下载:[xml.tar.bz2];

向下

收益率意味着德尔福。 利弊。 找到类似的分支


oxffff ©   (2007-10-15 20:14) [0]

C#具有这样的Yield构造。
我想,为什么我们实际上不在Delphi中实现相同的功能。
因此,例如,现在,如果您需要按需形成集合,那么这是很现实的,其语法类似于yield C#。
这是什么样的 小ASM代码

现在是什么

正确确定局部参数
保存和恢复上一个呼叫的上下文。
更改堆栈中的位置时,对EBP寄存器进行调整。

还没什么

仍然需要完成通过收益率对SEH框架的调整,当然还有在更改位置时的调整。 因此,除例外外,不会调用内部终结器。

用法示例。

数字,指数,计数器,Res:整数;
开始
对于i:= 1到10做收益(i);
产量(11);
产量(24);
对于i:= 1到10做收益(trunc(sin(i)));
产量(15);
g:= 1;
对于i:= 1到10
开始
g:=截号(sin(i));
产量(trunc(g * cos(i * 2)));
结束;
产量(g + 10);
数字:= 2;
指数:= 8;
计数器:= 1;
Res:= 1;
而计数器<指数做
开始
Res:= Res *数字;
产率(Res);
inc(counter);
结束;
结束;



aesma   (2007-10-15 20:16) [1]

请问是什么样的收益率。



oxffff ©   (2007-10-15 20:18) [2]

一个简化的例子。 最重要的是,查看消息输出顺序。

公共静态IEnumerable Power(整数,整数指数)
{
收益回报1;
Console.Write(“我们在这里”,i);
收益回报2;
Console.Write(“我们又在这里”,i);
收益回报3;
}

静态void Main()
{
//显示2的幂,直至指数8:
foreach(Power in i(2,8))
{
Console.Write(“ {0}”,i);
}
}

屏幕将显示以下顺序
1 <-这是从Main推断出来的
我们在这里<-这是从力量推断出来的!!!!!!
2 <-这是从Main推断出来的
我们又在这里<-这是从力量推断出来的!!!!!!
3 <-这是从Main推断出来的



oxffff ©   (2007-10-15 20:21) [3]

尤其是不了解没有按类型提出问题
“为什么?一切都可以那样做。”

立即为他们做出反例

不太了解以常规方式实施该示例。
只有一个条件。
所有元素均应要求形成。
而不是首先形成,然后显示。
出于好奇,让我们比较一下您的代码和我的代码。

程序TYieldObject.YieldUseProc;
var i,g:整数;
数字,指数,计数器,Res:整数;
开始
对于i:= 1到10做收益(i);
产量(11);
产量(24);
对于i:= 1到10做收益(trunc(sin(i)));
产量(15);
g:= 1;
对于i:= 1到10
开始
g:=截号(sin(i));
产量(trunc(g * cos(i * 2)));
结束;
产量(g + 10);
数字:= 2;
指数:= 8;
计数器:= 1;
Res:= 1;
而计数器<指数做
开始
Res:= Res *数字;
产率(Res);
inc(counter);
结束;
结束;



Prohodil Mimo ©   (2007-10-15 20:25) [4]

请重复,我没有时间记录。



oxffff ©   (2007-10-15 20:28) [5]

我请你合理表达意见。
参数在这里:
代码大小
-执行速度。



vpbar ©   (2007-10-15 20:34) [6]

看到代码会很有趣。 还是商业秘密?



oxffff ©   (2007-10-15 20:36) [7]


>看到代码将非常有趣。 还是商业
>秘密?


他是。 这是一个秘密。 草稿。
http://delphimaster.net/view/15-1192221654/
[47]



aesma   (2007-10-15 20:37) [8]

我认为它更漂亮。

(定义返回的几个数字 ..(lambda() .....(值1 2 3 4)) (定义主 ..(lambda x ....(for-each(lambda(a) .................(printf“〜A〜%” a))x))) (带有值的调用返回几个主数字)

你怎么看?



oxffff ©   (2007-10-15 20:38) [9]


>您如何看待?


oxffff©(15.10.07 20:21)[3]



oxffff ©   (2007-10-15 20:41) [10]


>他是。 这是一个秘密。 草稿。

当然这不是秘密。 :)



vpbar ©   (2007-10-15 20:42) [11]

oxffff©(15.10.07 20:36)[7]
嗯。 有趣的主意。 要尝试



aesma   (2007-10-15 20:46) [12]

oxffff©(15.10.07 20:21)[3]

抱歉,我可能很难理解,只是无法从p3中读取您的代码。
请简要说明您想告诉他们的内容。
您可以一次从一个函数返回多个值吗?
如果不是,那么此糖的作用是什么,您仍将使用外部循环来处理这些值。



oxffff ©   (2007-10-15 20:49) [13]


> aesma(15.10.07 20:46)[12]


所有元素均应要求形成。
该函数不会立即返回设置。 每个下一个元素都是根据请求动态计算的。 :)



aesma   (2007-10-15 20:50) [14]

>所有元素均根据要求形成。

它是什么样的?



oxffff ©   (2007-10-15 20:53) [15]


>它是什么样的?


我们必须再次查看oxffff©(15.10.07 20:18)[2]。
仔细查看评论的时间,内容和内容 从哪里来 显示



aesma   (2007-10-15 21:26) [16]

好,这是一个已知的问题

(定义宏协程
(lambda(x.body)
`(letrec((+ local-control-state
(lambda(,x),@ body))
(恢复
(lambda(cv)
(通话/抄送
(λ(k)
(设置!+本地控制状态k)
(cv)))))))
(lambda(v)
(+ local-control-state v)))))

(定义主
(协程prtr
(恢复prtr 1)
(printf“我们在这里〜%”)
(恢复prtr 2)
(printf“在那儿〜%”)
(恢复prtr 3)))

(主要(lambda(a)
(printf“〜A〜%” a)))



tesseract ©   (2007-10-15 21:39) [17]


>何时,何地以及在何处仔细查看评论
>显示


比起不喜欢相同的抽象类-托管代码很酷,但是它的应用引起更多的问题。



oxffff ©   (2007-10-15 22:24) [18]


> aesma(15.10.07 21:26)[16]
>嗯,这是一个已知问题
>
>(定义宏协程
>(lambda(x.body)
>`(letrec((+ local-control-state
>(lambda(,x),@ body))
>(恢复
>(lambda(cv)
>(通话/抄送
>(λ(k)
>(设置!+本地控制状态k)
>(cv))))))
>(lambda(v)
>(+ local-control-state v)))))
>
>(定义主
>(协程产品
>(恢复1)
>(printf“我们在这里〜%”)
>(恢复2)
>(printf“在那儿〜%”)
>(恢复prtr 3))
>
>(主要(lambda(a)
>(printf“〜A〜%” a)))


现在,将所有内容捆绑在一起。
并举一个完整的例子[3]。



oxffff ©   (2007-10-15 22:28) [19]


> tesseract©(15.10.07 21:39)[17]
>
Quoted1 >>仔细查看评论的时间,地点和地点
>
>>显示
>
>
>什么不喜欢相同的抽象类控制
>代码很酷,但是使用它会引起更多问题。
>


首先,您在哪里看到托管代码?

其次,抽象类如何帮助您,使您将使用抽象类编写的代码比oxffff©(15.10.07 20:21)[3]中的代码短。
他也会这样做。

我们期待您的反馈,至少会涉及[3]实施的一部分

程序TYieldObject.YieldUseProc;
var i,g:整数;
数字,指数,计数器,Res:整数;
开始
对于i:= 1到10做收益(i);
产量(11);
产量(24);
对于i:= 1到10做收益(trunc(sin(i)));
产量(15);
g:= 1;
对于i:= 1到10
开始
g:=截号(sin(i));
产量(trunc(g * cos(i * 2)));
结束;
产量(g + 10);
结束;



alex_*** ©   (2007-10-15 22:47) [20]

喜欢我们对张伯伦的回答吗?



aesma   (2007-10-16 09:17) [21]

oxffff©(15.10.07 22:24)[18]


>现在,将所有内容捆绑在一起。
>并举一个完整的例子[3]。


我太懒了,但是如果您看,您可以在懒线程(本质上是其用户的功能)和延续(内部发生的事情)上找到yeld实现。



Игорь Шевченко ©   (2007-10-16 09:26) [22]

“在拐角处,两个年轻人正和一些
机械设备。 一位自信地说:“设计思想
不能停滞不前。 这是社会发展的规律。 我们将发明它。
一定要发明。 与Chinushin和保守派等官僚相反
像特维尔多洛夫(Tverdolobov)一样。
这里的非可擦除轮胎由退化的多结构纤维制成
胺键和不完全的氧基团。 但是我还不知道
如何使用中子再生中子反应堆。 Misha,熊! 那反应堆呢?

(c)星期一从星期六开始



Суслик   (2007-10-16 10:50) [23]

谢尔盖(Sergei),我仍然主张可以用常规工具完全代替产量。 此功能不是首先必需的。 恕我直言



Dmitry S ©   (2007-10-16 14:21) [24]

iii烂了 特别是在阅读http://rsdn.ru/?Info/Howtoask.xml之后。



Сусл ©   (2007-10-16 14:40) [25]


>某种恶魔。 特别是在阅读http://rsdn.ru/?Info/Howtoask.xml之后
>。

亲爱的,这与它有关。



KSergey ©   (2007-10-16 14:49) [26]

> oxffff©(15.10.07 20:18)[2]

在这里,我再次看这个例子,同样的想法吸引了我:印第安人仍然有奇怪的想法。
他们抓住了它,转动了循环,并从内而外从其完全调用了回调,为这件事想出了一种语言构造-并默默地前进...为什么?
好吧,好吧,显然我的想法太过硬了(但是,在我试图理解Boost“元编程”的过程中,我已经确信了这一点)



Dmitry S ©   (2007-10-16 14:50) [27]


>麦芽©(16.10.07 14:40)[25]

为什么既没有意义也没有本质。
不是每个人都处理C#,也不是每个人都知道Yield是什么。 如果作者想讨论创建此问题 他自己 在德尔福,他为什么不解释它是什么 ?



atruhin ©   (2007-10-16 15:56) [28]

原则上,解析起来很方便。 与callack相比
无需记住其中一种程序的当前状态。



KSergey ©   (2007-10-16 16:05) [29]

> Dmitry S©(16.10.07 14:50)[27]
>如果作者想讨论创建此问题
>在德尔福,为什么不向他解释这是什么?

第二号帖子仔细阅读了吗?



KSergey ©   (2007-10-16 16:09) [30]

> atruhin©(16.10.07 15:56)[28]
>原则上,解析起来很方便。
>与Callack相比,
>无需记住其中一个过程的当前状态。

嗯,我看到这是自动发生的,在堆栈上...
还是说在通话之间保存某个回调状态?
顺便说一句,也许这是此操作的窍门-是否有必要通过调用回调函数将一些数据传输到回调内部?
我们将需要一些真实的例子来尝试解决这个问题。



DiamondShark ©   (2007-10-16 16:54) [31]

我在任何雅格语中都遇到过的最疯狂的语言构造。

正如Puzaty Pasyuk所说:“如果您需要该死的,那就去找魔鬼。”

如果您需要根据请求即时计算元素,请在IEnumerator.MoveNext()中进行计算。



oxffff ©   (2007-10-16 19:14) [32]


> KSergey©(16.10.07 16:09)[30]
>> atruhin©(16.10.07 15:56)[28]
Quoted1 >>原则上,解析起来很方便。
>
引用1 >>
quoted1 >>无需记住其中一个程序的当前状态。
>
>
>嗯,我看到这是在堆栈上自动发生的。
> ..
>还是意味着保存某个回调状态
>通话之间?
>顺便说一句,也许这就是行动的筹码
>有必要通过以下方式将某些数据传输到回调内部
>调用回调函数?
>有必要尝试一些真实的例子
>在这件事上。


有到我的草稿的链接,但有效。
也许尝试以通常的方式即时实现[3]。 然后最终评估设计目的。

:)



tesseract ©   (2007-10-16 21:19) [33]


>也许您可以尝试以通常的方式实现[3]
>即时。 然后最终评估设计目的。
>


您执行一个正常的例子-在这个例子中,您会变得懒惰。 从任何狡猾的sh-shnyh的东西,如此恶心。 我自己迷上了叛国罪-您的视力表除了输入功能的计数器外还承受其他负荷吗?



oxffff ©   (2007-10-16 21:48) [34]


>您举了一个正常的例子-在这个例子中我们变得懒惰。 来自
>各种狡猾的sh-shnyh东西,如此恶心。 我在这里
>他迷上了叛国罪-除柜台外,这是您的视力表
>输入功能会带来不同的负担吗?


您的问题有一个答案。

>懒惰深入研究

现在,如果您按照您所说的使用抽象类,那么您将花费更多的精力,并具有相同的功能。

>我自己迷上了叛国罪-您的视力表除了用于输入>功能的计数器外,还会承受其他负载吗?

我给了源链接,也许你应该看看。

顺便说一句,您没有回答oxffff©(15.10.07 22:28)[19]



tesseract ©   (2007-10-16 21:58) [35]


>顺便说一句,您没有回答oxffff©(15.10.07 22:28)[19]


您说它更快,请写信给我,我如何能快速将处理类添加到代码中,例如,十进制5.4数据库中的字段而无需重写几千行代码?



oxffff ©   (2007-10-16 22:44) [36]


> tesseract©(16.10.07 21:58)[35]
>
引用1 >>顺便说一句,您没有回答oxffff©(15.10.07 22:28)[19]
>
>
>你说更快我写我如何更快
>在代码中添加处理类,例如,十进制数据库中的字段
> 5.4是否无需重写几千行代码?


我认为您应该再次阅读本主题
而且,由于在传递状态及其状态时对上下文的隔离更加复杂,因此根据抽象类按需实现数据集元素的非线性形成的实现这一事实(顺便说一下,我们仍然不知道您的意思)将更加耗时。继续时的恢复以及处理算法的分离。

因此,将您的抽象类交给工作室。

而且,数据库。
您要重写什么DBMS。 为什么呢
有关系代数。 不需要产量。
首先,subd返回一个现成的最终数据集,该集中的数字是已知的,并且根据关系代数定律(即 实际上,它是一种(计算方法)。



tesseract ©   (2007-10-16 23:00) [37]


>因此,将您的抽象类交给工作室。


我们来看一下带有后代的Tfield层次结构,以及它的请求也可以在编译阶段轻松找到的事实。


> First subd返回完成的最终数据集,
>集合中的数字已知,并且计算数据元素
>根据关系代数定律,即 事实上,他是一个人
>(计算方法)。


嗯,C SQL工作吗? 参照完整性常常会崩溃。 只需正确使用Tfield,即可省去很多麻烦。 在这里,我参加的课程比AV早了三年-我可以预测您的成绩吗? (嗯,我想在全国范围内添加)。



oxffff ©   (2007-10-16 23:20) [38]


> tesseract©(16.10.07 23:00)[37]


启蒙之前,请再次阅读本主题。
字段类型的包装器的哪一侧是指提取DBMS数据的方法。
您仍然可以打开并重新读取数据吗?

Tfield-什么构成一个数据元素? 这只是一个包装。

>嗯,c SQL起作用了吗?

怎么了 汽车制造? 可能没有生产熨斗的公司。 就是这个

我个人觉得您需要重新读取数据

>参照完整性常常会崩溃。

特别是这些话之后。
通常,您急需阅读有关NFBK和更高版本的信息,并急需编辑曲线触发器。

现在一般就这个话题。
在重新考虑自己的思维方式之前,您将不会了解收益的优点和缺点。

如果您想最后感受一下差异。 我再重复一遍
用标准工具实现我的示例。



pasha_golub ©   (2007-10-17 11:12) [39]


> oxffff©(16.10.07 23:20)[38]


>启蒙前再次阅读本主题。

无需倒入这样的短语。 他们只排斥。 你有一个真实而必要的例子吗? 还是只是一个计算,就可以摆脱宿醉,用ShowMessage“ s余弦值?

还有上述内容:

> DiamondShark©(16.10.07 16:54)[31]
>如果您需要根据需要即时计算元素,请计算
>在IEnumerator.MoveNext()中。



KSergey ©   (2007-10-17 11:36) [40]

> oxffff©(16.10.07 19:14)[32]
>也许您可以尝试以通常的方式实现[3]
>即时。 然后最终评估设计目的。

我看了 oxffff©(15.10.07 20:18)[2]
我决定了解这种构造的工作原理(顺便说一下,有那么多未使用的论点是什么?使用奖金时,可能会更清楚一点吗?)。
看了[3]。 我看到,实际上,有一个函数调用了其他Yield()函数(是的,我看到的是这种痔疮的实现!)。 很有可能将foreach主体转移到这个Yield()上,同时在需要时调用它。 当我想存储此函数的各个调用之间的某些变量的值时,仅看到其实现的一个问题,仅此而已。 但是,这个问题或多或少容易解决。

那么总的来说呢?



Сусл ©   (2007-10-17 12:02) [41]


> [39] pasha_golub©(17.10.07 11:12)
>> oxffff©(16.10.07 23:20)[38]
Quoted1 >>启蒙前请再次阅读本主题。
>不要倒这些短语。 他们只排斥


+ 3(即强烈支持)。



oxffff ©   (2007-10-17 12:06) [42]

pasha_golub©(17.10.07 11:12)[39]
KSergey©(17.10.07 11:36)[40]

例如,如果不是一种算法,而是两种算法或10算法用于计算。 并且算法可以组合。
因此,我举一个非平凡元素算法的例子。

如果实施,则使用标准方法在MoveNext中进行计算
最重要的是,您必须通过从那里隔离状态和指向下一个计算算法的指针来“解析算法”,并将所有这些都保存到对象的字段中。 我再说一遍,这是可以做到的。
但是,使用另一种计算算法的方法将非常耗时。 试想一下这些方法是否可以组合。

在C#中,他们在IL的编译器级别引入了此构造。

我很快就会对这项工作进行或多或少的详细描述。 英文为真。 :)



KSergey ©   (2007-10-17 12:28) [43]

我还是不明白它的关系 oxffff©(17.10.07 12:06)[42] и

> KSergey©(17.10.07 11:36)[40]
>我发现实际上有一定的功能,
>这会导致其他的Yield()函数 (我在这里谈论的是实现标准工具,而不是编写示例来说明具有工具)

那下蹲呢



oxffff ©   (2007-10-17 13:32) [44]


> KSergey©(17.10.07 12:28)[43]


您以我的示例标准工具为例,差异将对您显而易见。 吹成这样
因此它是通用的,也就是说,它本身会记住任何情况下值传输之间的状态。

:)



Игорь Шевченко ©   (2007-10-17 14:00) [45]

oxffff©(17.10.07 13:32)[44]


>吹成这样,
>使其具有通用性,即它本身会记住状态
>在任何情况下传递值之间


我也是Bin Newton。



pasha_golub ©   (2007-10-17 15:58) [46]


> oxffff©(17.10.07 13:32)[44]


>也就是说,她自己想起了价值之间传递的状态
>适用于任何场合。

对不起,她自己呢? 这里的程序员已经不需要sholi吗?

会有一个优雅的生活例子,也许这是真正需要的东西。 所以我个人就是不了解她。



Virgo_Style ©   (2007-10-17 18:15) [47]

我开始悄悄地怀疑自己是个傻瓜...事实证明,我不是唯一一个不了解它是什么以及为什么需要它的人%-)



oxffff ©   (2007-10-17 19:34) [48]


> pasha_golub©(17.10.07 15:58)[46]
>
>> oxffff©(17.10.07 13:32)[44]
>
>
quoted1 >>,就是说她自己记得状态之间传递的价值
>
任何情况下都引用1。
>
>怎么样,对不起,她自己? 不再需要这里的程序员
> sholi?
>
>会有一个优雅的生活例子,也许这是真正需要的东西。
>所以我个人只是不了解它。

> Virgo_Style©(17.10.07 18:15)[47]
>但我已经开始悄悄怀疑自己是个傻瓜...事实证明我并不孤单>我不明白它是什么以及为什么需要它%-)

您是oxffff©(15.10.07 20:18)[2]仔细看过吗?

我再说一遍

公共静态IEnumerable Power(整数,整数指数)
{
收益回报1;
Console.Write(“我们在这里”,i);
收益回报2;
Console.Write(“我们又在这里”,i);
收益回报3;
}

调用yield return 1后,控件将进入一个外部过程,即调用MoveNext的过程。
在下一次调用MoveNext之后,控制权将立即转移到
Console.Write(“我们在这里”,i),并在yield return 2之后传递回去。
并且内部声明的所有变量的状态将自动保存(无论如何,您无需为此付出任何努力)。

如果您现在不明白。
然后要么等待文章(该包是英文版),要么在ASM上查看代码。 链接在第一页。

顺便说一下,现在我已经对其进行了改进,因此Yield适用于任何类型。

或用C#编写示例,然后在调试器下查看。




oxffff ©   (2007-10-17 19:39) [49]


>并且将声明内部所有变量的状态保存
>自动(在任何情况下,您都无需附加
>此工作)。


在此示例中,变量未在Power中声明,但是如果声明了变量,则它们的状态在控制权转移到收益之间将保持不变。
也就是说,从产量到产量,将保存内部声明的变量的状态。



Virgo_Style ©   (2007-10-17 21:32) [50]

f 通过冥想,他似乎了解了实际发生的事情。 我不需要阅读英语,这可能是必要的。

也许这需要特定的经验,但是从[2]起,我只能假定程序员不得不混淆代码和头痛(



oxffff ©   (2007-10-17 22:22) [51]


>
>也许这需要特定经验,但来自[2]
>我只能以为混淆代码和头部
>程序员的痛苦(


oxffff©(17.10.07 12:06)[42]



Virgo_Style ©   (2007-10-17 23:43) [52]

oxffff©(17.10.07 22:22)[51]
oxffff©(17.10.07 12:06)[42]


Virgo_Style©(17.10.07 21:32)[50]

我一次不喜欢递归,现在仍然不喜欢递归。 但是当涉及到在子目录中查找文件时,对我来说很清楚这是完成此任务和类似任务的最便捷工具。

但是尚未宣布使用该工具的任务。

通常,采用这种风格,即使您证明两次两次等于四,也不会说服任何人。 永久性地提及自己和大师的语调不合理的例子不是一种可以说服的风格。

我会说-有这样的设计,它可以这样工作,可以在这样的任务中使用。 优点如下。 就是这样,对话开始了。 因此-关于任何具有明显“宗教”内涵的对话(



oxffff ©   (2007-10-18 00:33) [53]


> Virgo_Style©(17.10.07 23:43)[52]


实际上,我们该如何与不仅不想从一开始就读这个话题,甚至想讨论话题的人们进行对话。
甚至有些人对所有事物都进行了评估。
争论在哪里?
提出先生们的论点。
但是在大多数情况下,没有人希望阅读,更不用说打开C#项目,打开调试器并查看进度了。
尽管我已经重复多次,但请参见[0],[2],[3]或源代码。

谁带来了至少一个代码演示?
有一个话题来自“为什么?可以这样做吗?”类别
我当然同意,但是对于那些具有许多状态和计算算法的算法而言,什么是有价值的?
因此,据信宗教信仰对您而言更有可能。
我们只承认我们的信仰之一。
在这个主题中,我反复表达了这种设计的目的及其便利性。

如果对任何人都变得有趣,那么我将仅以您的论点以代码形式进行对话和讨论。



FeiFei   (2007-10-18 09:06) [54]

oxffff©(18.10.07 00:33)[53]

>一个聊天记录,来自“为什么?可以这样做吗?”类别
>我当然同意,但是对于那些具有许多状态和计算算法的算法而言,什么是有价值的?

为什么将Delphi用于此类算法?



Игорь Шевченко ©   (2007-10-18 09:07) [55]


>在此主题中,我反复表达了此设计的目的
>及其便利。


老实说,我读过,但没有看到它的方便。 你看起来不好吗?



KSergey ©   (2007-10-18 10:04) [56]

> oxffff©(18.10.07 00:33)[53]
>实际上,我们如何与不仅是
>不想从一开始就阅读该主题,而是想一想主题
>对话。

您应该放慢自大吧? 我给出了一些最歪斜的示例,其中包含一些未使用的变量(因此,目前尚不清楚是否需要使用它们)。 这是关于[2]的信息。 从[2]中可以清楚地知道构造的工作原理。 所有人都希望它早已明白。

但是,以[19]等为例。 -不能说服Nifiga,tk。 目前尚不清楚此功能之外的内容,即 在foreach内部(或者换句话说,在Yeld内部)。
那时候它是可见的-然后将进行实质性的讨论,即“如何用传统方式编写它,并且更容易”。 同时-在一般情况下-只需调用某些方法/函数Yeld即可完全解决此问题。 没有“ AFM插入”。



Virgo_Style ©   (2007-10-18 10:28) [57]

oxffff©(18.10.07 0:33)[53]

您已经写了太多关于迟钝逆行的文章,以至于我们可以写三遍什么,为什么和如何写的书。
而是……这次对话让我非常想起“驴子汉克斯”,请原谅我的法语。

我会在括号中注意到这是一个Delphi论坛。 就我个人而言,我的资格不允许我在我不知道的环境中(我可以通过gprs下载)用我不知道的语言来发现在调试器下进行秘密构造的优点。 我不是在谈论这样做的愿望。

我认为我进一步参与该线程是没有意义的,至少直到没有明确的描述为止。



vpbar ©   (2007-10-18 10:53) [58]

>>牛津
你很酷,你超级酷。 (也许您不必为此感到骄傲,但这些都是琐事)
继续吧 这种设计有时很有用。

>>其他
和例子-好吧,我在某处有一本关于离散数学的书,因此作者使用yeld以抽象语言(类似于Pascal :))给出了构造集合和其他东西的例子。 如果找到它,我将在这里打印。
我还在这里使用文件搜索和处理,因此这样做会更加方便
foreach(NextFile中的字符串文件名(根,掩码)) { //Console.Write(FileName); }
而不是通过kalbaki或返回列表。

PS
谢尔盖(Sergey),如果您仍然使用Delphi做回报的类似物,那么我个人将向您发送啤酒(或类似物)。 :)



oxffff ©   (2007-10-18 10:57) [59]


> KSergey©(18.10.07 10:04)[56]
>> oxffff©(18.10.07 00:33)[53]
引用1 >>实际上,我们该如何与非
>只
他们不想从一开始就读这个话题,而是想一想这个话题
>
quoted1 >>对话。
>
>您会减少自大,是吧? 例子列举了最歪的一堆
>一些未使用的变量(因此完全
>尚不清楚是否需要它们。 这是关于[2]的信息。 如何运作
>设计-从[2]可以清楚地看到。 和每个想要它很久的人
>了解。


您会是正确的,亲爱的。
然后我也可以露出牙齿。

现在顺序。
您没有指定上下文就撕毁了[19]。 [3]中的完整示例。

接下来,我告诉您5以通常的方式实现[3]。
那你就会明白
特别选择,以便计算算法
元素已经改变,还有很多状态
以通常的方式给实施带来不便和困难。
鉴于下一个元素的计算状态“隔离”(包括该算法的参数和算法本身)。

如果您声称了解算法。 我仔细阅读了所有内容。
事实并非如此。 你什么都不懂

请参见[48]。 它有一个关键词

并且内部声明的所有变量的状态将自动保存(无论如何,您无需为此付出任何努力)。



euru ©   (2007-10-18 11:02) [60]

我会尽力帮助oxffff。 然后他不知何故地进行了循环(可能是收益率错误地为自己安排了)。
用C#编写程序,因为 有一个全职实施 产量。 它使用实现迭代 产量没有它。

using System;
using System.Collections;

namespace Test
{
class Program
{
 public static void Main(string[] args)
 {
  int count = 4;
  foreach (int i in YieldFunc(count))
  {
   Console.Write("{0}", i);
  }
 
  foreach (int i in new Yield(count))
  {
   Console.Write("{0}", i);
  }

  Console.WriteLine("\nPress any key...");
  Console.ReadKey();
 }
 
 public static IEnumerable YieldFunc(int count)
 {
  Console.Write("Значения квадратов от 1 до ");
  yield return count;
  int s = 0;
  for (int i = 1; i <= count; i++)
  {
   Console.WriteLine();
   yield return i;
   Console.Write(" * ");
   yield return i;
   Console.Write(" = ");
   yield return i * i;
   s += i * i;
  }
  Console.Write("\nСумма квадратов равна ");
  yield return s;
 }
 
 private class Yield : IEnumerable, IEnumerator
 {
  private int count;
  private int current;
  private int state;
  private int s;
 
  public Yield(int count)
  {
   this.count = count;
  }
 
  public IEnumerator GetEnumerator()
  {
   return this;
  }
 
  public Object Current
  {
   get
   {
    switch (state)
    {
     case 0:
      Console.Write("Значения квадратов от 1 до ");
      state = 1;
      return count;
     case 1:
      Console.WriteLine();
      state = 2;
      return current;
     case 2:
      Console.Write(" * ");
      state = 3;
      return current;
     case 3:
      Console.Write(" = ");
      state = 1;
      s += current * current;
      return current * current;
     default:
      Console.Write("\nСумма квадратов равна ");
      return s;
    }
   }
  }
 
  public bool MoveNext()
  {
   if (state == 1) current++;
   if (state == 4) return false;
   
   if (current > count) state = 4;
   return true;
  }
 
  public void Reset()
  {
   current = 0;
   state = 0;
   s = 0;
  }
 }
}
}



Игорь Шевченко ©   (2007-10-18 11:09) [61]

“他们离人民太远了”(三)



oxffff ©   (2007-10-18 11:12) [62]


> vpbar©(18.10.07 10:53)[58]
> >>牛津
>您很酷,您超级酷。 (也许您不必为此感到骄傲,
>但这些都是琐事)
>继续。 这种设计有时很有用。
>
> >>其他
>还有例子-在某个地方,我有一本关于离散数学的书,
>因此,作者使用的是抽象语言(类似于pascal
> :))使用yeld给出了构建集的示例
>以及其他内容。 如果找到它,我将在这里打印。
>我也在这里使用文件搜索和处理,所以我
>这样会更方便
>
> foreach(NextFile中的字符串文件名(根,掩码))
> {
> //Console.Write(FileName);
>}
>
>而不是通过kalbaki或返回列表。
>
> PS
>谢尔盖(Sergey),如果您仍然使用Delphi做回报的模拟,那么
>我个人向您发送啤酒(或同等的啤酒)。 :)


当星星,这是非常糟糕的。
它不止于我。 :(

如果在语言级别引入此构造,则需要在编译器上输入语言,并且需要使实现与C#中的相同。
由于我必须在实现中操纵堆栈。

您甚至可以考虑我关于改进此构造的建议(比C#更好,因为try catch存在局限性)
即关于SEH的推广。 但是在这里我们必须从速度出发。
我昨天写了一篇文章,要求检查一位西方同事。



oxffff ©   (2007-10-18 11:19) [63]


> euru©(18.10.07 11:02)[60]
>我将尽力帮助oxffff。 然后他不知何故地循环了(大概
>产量错误地放置在家里)。


谢谢你的例子。
我希望他们来。

PS
我正确设置了收益率。 是故意的。
算法更加复杂。
而且要隔离状态甚至更多,算法也不容易。
想象一下一种算法在另一种算法中的嵌套。
或其任意元素的组合。
然后,复杂性将进一步增加。

并且要隔离成扁平的外壳将是非常困难的。

但是这里的关键是有一种方法可以使用Yield将其移植到编译器



oxffff ©   (2007-10-18 11:19) [64]


> euru©(18.10.07 11:02)[60]
>我将尽力帮助oxffff。 然后他不知何故地循环了(大概
>产量错误地放置在家里)。


谢谢你的例子。
我希望他们来。

PS
我正确设置了收益率。 是故意的。
算法更加复杂。
而且要隔离状态甚至更多,算法也不容易。
想象一下一种算法在另一种算法中的嵌套。
或其任意元素的组合。
然后,复杂性将进一步增加。

并且要隔离成扁平的外壳将是非常困难的。

但是这里的关键是有一种方法可以使用Yield将其移植到编译器



KSergey ©   (2007-10-18 11:57) [65]

这是明星,亲爱的版本...

> oxffff©(18.10.07 10:57)[59]
>亲爱的,你会表现得很正常。
>然后我也可以露出牙齿。

是的,任何数字! 我并没有对每个人都变得粗鲁(在这个话题中:)。

>现在按顺序。
>您撕裂了[19]而未指定上下文。 [3]中的完整示例。

是的,该死的不是一个完整的多摩示例,您能理解吗?
我要么看不到任何东西(再次不是我的主张),要么仍然没有主要的东西:foreach在何处使用。

如果我们假设多摩(forta)的行为(假设是,也就是说,不在海豚上,那很明显),例如:

foreach(YieldUseProc()中的整数ii) 开始 Writeln(“ ii =” + IntToStr(ii)); 结束

然后只需在[3]中向代码添加功能即可解决现有编译器框架中的所有问题

程序收益率(ii:整数); 开始 Writeln(“ ii =” + IntToStr(ii)); 结束

所以你终于明白了 没有 完整代码??

PS
注意,我使用标签来格式化代码。 它仍然更容易阅读。



oxffff ©   (2007-10-18 12:10) [66]


> KSergey©(18.10.07 11:57)[65]


我不认为如果使用格式化,您会变得更清晰。
总的来说,时间将到,您将了解所有内容。

>程序收益(ii:整数);
>开始
> Writeln(“ ii =” + IntToStr(ii));
>结束;

这让我微笑。
完全理解,您不会看到生成元素的方法与其使用者之间的区别,以及枚举器“ a”的目的。
好吧,好吧。

顺便说一句,我可以改善您的代码。
这样做而不是调用Yield,立即插入对Writeln的调用。



oxffff ©   (2007-10-18 12:19) [67]


>因此,您终于明白没有完整的代码了!

我们如何使用ASM?
你没看吗
也许您应该收看。 我给了链接。



Игорь Шевченко ©   (2007-10-18 12:26) [68]

伊万·库利宾(Ivan Kulibin)的孩子们。 多少钱 :)



KSergey ©   (2007-10-18 12:32) [69]

> oxffff©(18.10.07 12:10)[66]
>总的来说,时间到了,您将了解所有内容。

实际上-我怕什么?
我和可用的工具足以解决我的问题。
我认为没有其他理由要回答。



oxffff ©   (2007-10-18 12:40) [70]


> Igor Shevchenko©(18.10.07 12:26)[68]
>伊万·库利宾(Ivan Kulibin)的孩子。 多少钱 :)


因此,我们是您的孩子(就谁为我们树立榜样而言)。
:)



oxffff ©   (2007-10-18 13:36) [71]

这是文章的一部分。

C#在Delphi中实现yield。

C#yield关键字用于向枚举器对象提供值或表示迭代结束。 收益构建的主要思想是应要求生成收集项,并立即将其返回给枚举数使用者。 在某些情况下,您可能会发现它很有用。

如您所知,枚举器有两个方法MoveNext和GetCurrent。
但是产量如何运作?

实施技术细节

当我第一次看到这种结构时,我问自己,MoveNext和GetCurrent在哪里?
该函数返回枚举器对象或接口,但是在任何地方都没有明确构造枚举器。 因此,有一些秘密机制使其成为可能。
以及它如何真正起作用?
花了一些时间调试器和答案后。

简而言之,编译器生成某种特殊形式的对象,当然
有一些神奇的MoveNext和GetCurrent。

而且因为这种构造对我们的Delphi社区可能有用,所以我问自己,我可以为Delphi进行收益支持而做些什么,而无需使用在C#中保存use形式的特殊方法来调用。
我想保留yield C#语法,但是稍后我稍微更改了语法,几乎像在C#中一样,将实现委派给外部过程,但带有附加的参数yield wrapper对象。 第一次是虚拟过程。

但是,当然,我必须归纳所有类型的实现。

当然还有我自己的问题。
我可以改善C#良率实现吗? 可能是。

我从程序员的角度出发。
像这样的东西

VAR
数字,指数,计数器,Res:整数;
开始

.....
Res:= 1;
而计数器<指数做
开始
Res:= Res *数字;
产率(Res);
inc(counter);
结束;
结束;

我必须实现一些实现魔术MoveNext和GetCurrent的类。
而且,如果我(您)使用本地var(放在堆栈上),则必须实现某种机制以确保最终类型不会发生内存泄漏,并且必须实现某种机制以确保使用
当由于外部原因在上次yield调用之后更改了本地var的实际位置时,有效的本地var(例如,枚举数作为参数传递给其他过程,因此堆栈中的位置变为另一个)。

因此,在每个yield调用之后,我必须保留本地var和处理器寄存器的状态,
清理堆栈并返回给枚举器使用者,
在下一次对MoveNext的下一次调用之后,我必须分配堆栈,还原本地var和处理器寄存器的状态,即模拟什么都没有发生。
当然,我必须在最后提供一个正常的过程。



pasha_golub ©   (2007-10-18 14:38) [72]

euru©(18.10.07 11:02)[60]

您可以在示例函数中添加更复杂的内容吗? 好吧,例如,不同类别的对象或其他东西。 例如,该示例通常很清楚,但仅作为示例。 我希望可以在没有做出任何合理努力的情况下不使用Yeld进行部署。



Zeqfreed ©   (2007-10-18 15:21) [73]

#!/ usr / bin / python def奇数功率(n): m = n 而True: 产量m m = m * n * n def factorials(): n = 6#以3开始! c = 3 而True: 产量n c = c + 1 n = n * c def标志(): s = -1 而True: 产量 s = s *(-1) 定义正弦(x): p =奇数幂(x) p.next()#跳过优先级 f =阶乘() s =符号() 而True: 产量x a = p.next() b = f.next() f.next()#跳过偶数阶乘 c = s.next() x = x + c * a / b s =正弦(3.14 / 2) 而True: 尝试: 打印str(s.next()) 除了: 打破

举个例子:)



Zeqfreed ©   (2007-10-18 15:24) [74]

好吧,像往常一样,所有缩进都被吃掉了。 尝试第二。

#!/ usr / bin / python def奇数功率(n): m = n 而True: 产量m m = m * n * n def factorials(): n = 6#以3开始! c = 3 而True: 产量n c = c + 1 n = n * c def标志(): s = -1 而True: 产量 s = s *(-1) 定义正弦(x): p =奇数幂(x) p.next()#跳过优先级 f =阶乘() s =符号() 而True: 产量x a = p.next() b = f.next() f.next()#跳过偶数阶乘 c = s.next() x = x + c * a / b s =正弦(3.14 / 2) 而True: 尝试: 打印str(s.next()) 除了: 打破



tesseract ©   (2007-10-18 22:05) [75]


> Zeqfreed©(18.10.07 15:24)[74]


python的知识不是很热门,但是我了解得更多。 在1中,有用的是在有派克天鹅癌的delphi中。



oxffff ©   (2007-10-19 02:54) [76]

增加了本地程序的所有SEH框架的动态组装/拆卸,并在发生本地数据移位的情况下对其进行了调整。



ZeroDivide ©   (2007-10-24 08:39) [77]

http://hallvards.blogspot.com/2007/10/sergey-antonov-implements-yield-for.html

:)



KSergey ©   (2007-10-24 09:30) [78]

根据该文章,ZeroDivide©友好地找到了该链接。

什么,这真的有效吗?

过程TForm1.Button1Click(发送者:TObject); var a:字串; 开始 为了自我 Memo1.Lines.Add(a);结束;

我懒得检查,对不起。
还有更多。

> oxffff©(18.10.07 13:36)[71]

是否可以给出完整的使用示例? 即 到底什么是“内部”,什么是外部? (我不是说实现)。



KSergey ©   (2007-10-24 09:33) [79]

> pasha_golub©(18.10.07 14:38)[72]
>我想要点东西
>以合理的方式以任何方式很好地部署而不会屈服。
>

那太好了。
但是,原则上,我看到了该应用程序,因为 在继承的当前项目中,我需要处理在回调函数中使用的一堆全局变量,该全局变量只是在不传递内部void指针的情况下优雅地解决了该方法。 (敌人的术语仅仅是因为我不知道在Delphi中要强调什么术语。)

是的,我不会使用它,因为 我只有一部分是在海豚上,另一部分是在敌人上:)



ЗапомниСынок ©   (2007-10-24 16:56) [80]

自从2006诞生以来,在Delphi王国就出现了一篇关于在Delphi上实现Yield的文章,我想知道作者是否也一样?



Сусл ©   (2007-10-24 17:01) [81]

http://hallvards.blogspot.com/2007/10/sergey-antonov-implements-yield-for.html



oxffff ©   (2007-10-24 19:14) [82]


> RememberSon©(24.10.07 16:56)[80]
>在德尔福王国,有关在德尔福实施收益的文章
>从2006的开始就存在。有趣的是,同一位作者吗?


链接到工作室。



oxffff ©   (2007-10-24 19:20) [83]


> RememberSon©(24.10.07 16:56)[80]
>在德尔福王国,有关在德尔福实施收益的文章
>从2006的开始就存在。有趣的是,同一位作者吗?


http://www.delphikingdom.ru/asp/viewitem.asp?catalogid=1191 ?
作者不是我。 实现是不同的。

我建议比较最多的RememberSon©。



ЗапомниСынок ©   (2007-10-25 10:08) [84]

是的,我无事可做...



Страницы: 1 2 3 整个分支

论坛:“其他”;
当前存档:2007.11.25;
下载:[xml.tar.bz2];

楼上





内存:0.99 MB
时间:0.141 c
2-1193993515年
vl
2007-11-02 11:51
2007.11.25
向表添加数据


2-1193741998年
夸脱
2007-10-30 13:59
2007.11.25
Dbgrid细胞


2-1193682578年
mahab
2007-10-29 21:29
2007.11.25
正确的图像上传处理


15-1193146097年
伊万
2007-10-23 17:28
2007.11.25
使用二进制文件


2-1193932184年
Vlad0
2007-11-01 18:49
2007.11.25
从行尾开始





南非荷兰语 阿尔巴尼亚人 阿拉伯语 亚美尼亚 阿塞拜疆 巴斯克 白俄罗斯 保加利亚语 加泰罗尼亚 简体中文 中国(繁体) 克罗地亚 捷克 丹麦语 荷兰人 英语 爱沙尼亚语 菲律宾人 芬兰 法语
加利亚西语 格鲁吉亚语 德语 希腊语 海地克里奥尔语 希伯来语 印地语 匈牙利 北日耳曼语 印度尼西亚人 爱尔兰语 意大利语 日本 韩语 拉脱维亚 立陶宛 马其顿 马来语 马耳他语 挪威语
波斯语 波兰语 葡萄牙语 罗马尼亚 俄语 塞尔维亚 斯洛伐克 斯洛文尼亚 西班牙语 斯瓦希里 瑞典语 泰国人 土耳其 乌克兰 乌尔都语 越南人 威尔士语 意第绪语 孟加拉 波斯尼亚
宿务 世界语 古吉拉特语 豪萨语 苗族 伊博 爪哇 卡纳达语 高棉 老挝 拉丁语 毛利 马拉 蒙古人 尼泊尔 旁遮普 索马里 淡米尔文 泰卢固语 约鲁巴语
祖鲁
英文 Французский Немецкий Итальянский Португальский 俄文 Испанский