程序性[“裸ASP.NET”]与OOPy ASP.NET [英] Procedural ["bare ASP.NET"] versus OOPy ASP.NET
问题描述
在ASP.NET中编写WWW应用程序几年（以及其他几个框架）之后，我们的部门已经看到了可能看起来像b
的反击结论： />
在程序中编写ASP.NET代码方式（没有webcontrols和
而不使用一般的OOP概念）产生的代码可以更快，更具可扩展性。一般来说，一个裸ASP.NET
应用程序使用它的OOPy对应因子为2到10.
令人惊讶的副作用是程序版本减少了内存需求，更容易维护，更容易解释
和调试。虽然可重用性是OOPy版本中的一个目标，但是这个目标被证明是难以捉摸的，因为开发人员必须被教授复杂的任何新的可重用组件的复杂性（他可以只需将它b / b
插入应用程序而不完全理解它，因为，要设计一个可重复使用的组件，必须事先知道它的所有方式
将来会使用
，如果不是这样的话就很困难。
如果我们的程序员没有经验，我会把它弄清楚来b / b
缺乏经验。但这是我们编程小组的结论，
多年来使用各种语言在许多平台上编写软件
（OOP，程序和功能）。虽然OOP当然有它的位置（例如，它在编写实时的电子软件时特别有用），但这个地方似乎并不是万维网
申请表。我可能会补充一点，我们的开发人员非常熟悉互联网标准和协议，这对于一般的开发人员而言可能并非如此。
我们在WWW应用程序上的工作效率显着提高，因为我们接受了这个令人惊讶的结论。还有其他商店结束了
相同吗？其他ASP.NET开发人员的经验是什么？
Bob
After several years of programming WWW applications in ASP.NET (and
several other frameworks) our division has come to what might seem a
counterintiutive conclusion:
Writing ASP.NET code in a "procedural" manner (without webcontrols and
without utilizing OOP concepts in general) produces code that is
remarkably faster and more scalable. In general a "bare ASP.NET"
application outruns it''s OOPy counterpart by factors of 2 to 10.
Surprising side-effects are that the procedural version has reduced
memory requirements, is easier to maintain and it is easier to explain
and debug. While reusability was a goal in the OOPy versions, that
goal proved elusive, since a developer must be taught the intricacies
of any new reusable component he is given (he can''t merely plug it
into an application without understanding it fully) and because, to
design a reusable component one must know beforehand all the ways it
will be used in the future, something that is difficult if not
impossible.
If our programmers _were_ inexperienced, I would chalk this up to
inexperience. But this is the conclusion of our programming group,
which has written software on many platforms using various languages
(OOP, procedural, and functional) over many years. While OOP certainly
has it''s place (e.g., it is particularly useful in writing real-time
telecommunications software), that place does not seem to be WWW
applications. I might add that our developers are very familiar with
Internet standards and protocols, something that may not be true of
developers in general.
Our productivity on WWW apps has increased significantly since we
accepted this surprising conclusion. Have other shops concluded the
same? What are the experiences of other ASP.NET developers?
Bob
推荐答案
我不会评论速度，我不知道。但是我想使用一个控件所涉及的开销很大，这不仅仅是一块骨头。
现在，通过程序代码，你的意思是回应写出来的一切？如果
如此，我无法想象任何可能使Web应用程序更难以维持，扩展或重用的任何东西，那么。一旦学习曲线与学习如何使用服务器端Web控件相关联的学习曲线得到了解决（顺便说一下，这是一个学习曲线并不是那么大的b $ b） ，发展变得更容易。一旦创建了包含代码等的可重用控件，
开发变得更快。是的，没有人能够知道如何做到这一点
第一次100％ - 但是每个控件都变得精致并具有新功能
随着时间的推移而增加。
" parley" < PA ********** @ yahoo.com>在消息中写道
news：8a ************************** @ posting.google.c om ...
I won''t comment on the speed, as I do not know. But I guess the overhead
involved with using a control, that''s not just bare bones.
Now, by procedural code, do you mean Response.Write''ing everything out? If
so, I can''t imagine anything that would make a web app more difficult to
maintain, extend or reuse, then that. Once the learning curve associated
with learning how to use the server side web controls is taken care of (and
by the way, this is not that huge a learning curve), development becomes
easier. Once reusable controls that include code, etc are created,
development becomes even faster. Yes, no one can know how to do it right
100% the first time - but every control gets refined and has new features
added over time.
"parley" <pa**********@yahoo.com> wrote in message
news:8a**************************@posting.google.c om...
经过几年的ASP.NET编程WWW应用程序（以及其他几个框架），我们的部门已经看到了一个似乎是反作用的结论：
<在程序中编写ASP.NET代码方式（没有webcontrols和
，一般不使用OOP概念）产生的代码更快，更具可扩展性。一般来说，裸ASP.NET应用程序通过2到10的因子来表示它的OOPy对应物。
令人惊讶的副作用是程序版本减少了内存要求，更易于维护，更容易解释和调试。虽然可重用性是OOPy版本中的一个目标，但是这个目标被证明是难以捉摸的，因为开发人员必须学习他给出的任何新的可重用组件的复杂性（他不能仅仅插入它） />在没有完全理解的情况下进入应用程序）并且因为，为了设计一个可重用的组件，必须事先知道将来使用的所有方法，如果不是这样的话，那就很困难了。 >不可能。
如果我们的程序员没有经验，我会把这归结为缺乏经验。但这是我们的编程小组的结论，
多年来使用各种语言（OOP，程序和功能）在许多平台上编写软件。虽然OOP肯定有它的位置（例如，它在编写实时电信软件时特别有用），但这个地方似乎并不是WWW
应用程序。我可以补充一点，我们的开发人员非常熟悉互联网标准和协议，这对于开发人员来说可能并非如此。
我们在WWW应用上的工作效率显着提高因为我们接受了这个令人惊讶的结论。还有其他商店结束了吗？其他ASP.NET开发人员的经验是什么？
Bob
After several years of programming WWW applications in ASP.NET (and
several other frameworks) our division has come to what might seem a
counterintiutive conclusion:
Writing ASP.NET code in a "procedural" manner (without webcontrols and
without utilizing OOP concepts in general) produces code that is
remarkably faster and more scalable. In general a "bare ASP.NET"
application outruns it''s OOPy counterpart by factors of 2 to 10.
Surprising side-effects are that the procedural version has reduced
memory requirements, is easier to maintain and it is easier to explain
and debug. While reusability was a goal in the OOPy versions, that
goal proved elusive, since a developer must be taught the intricacies
of any new reusable component he is given (he can''t merely plug it
into an application without understanding it fully) and because, to
design a reusable component one must know beforehand all the ways it
will be used in the future, something that is difficult if not
impossible.
If our programmers _were_ inexperienced, I would chalk this up to
inexperience. But this is the conclusion of our programming group,
which has written software on many platforms using various languages
(OOP, procedural, and functional) over many years. While OOP certainly
has it''s place (e.g., it is particularly useful in writing real-time
telecommunications software), that place does not seem to be WWW
applications. I might add that our developers are very familiar with
Internet standards and protocols, something that may not be true of
developers in general.
Our productivity on WWW apps has increased significantly since we
accepted this surprising conclusion. Have other shops concluded the
same? What are the experiences of other ASP.NET developers?
Bob
关于开发人员结论的线索可以在您的留言中找到：
The clue as to your developer''s conclusions can be found in your message:
缺乏经验。但这是我们的编程小组的结论，
多年来使用各种语言（OOP，程序和功能）在许多平台上编写软件。虽然OOP当然是
可能太多年了，并且不愿意跟上。
这就是问题所在。以DOS为例。毫无疑问，你可以编写一个程序，用于运行比为Windows XP编写的程序快得多的
DOS。在创建多任务，多用户，网络运营
系统时，需要花费大量开销。但是为什么没有人再使用DOS有很多好的理由。
是使ASP.net面向对象的很多好理由。事实上，太多了，这需要b
来列举。当然，跟上最新的
编程技术是不舒服的。但如果你不这样做，那么如果短短几年你就会失业。
-
HTH，
Kevin Spencer
..Net开发人员
微软MVP
大事做成<很多小东西都是
。
" parley" < PA ********** @ yahoo.com>在消息中写道
news：8a ************************** @ posting.google.c om ...经过几年在ASP.NET中编写WWW应用程序（以及其他几个框架）之后，我们的部门已经看到了一个似乎是反作用的结论：
编写ASP.NET代码在程序性的中方式（没有webcontrols和
，一般不使用OOP概念）产生的代码更快，更具可扩展性。一般来说，裸ASP.NET应用程序通过2到10的因子来表示它的OOPy对应物。
令人惊讶的副作用是程序版本减少了内存要求，更易于维护，更容易解释和调试。虽然可重用性是OOPy版本中的一个目标，但是这个目标被证明是难以捉摸的，因为开发人员必须学习他给出的任何新的可重用组件的复杂性（他不能仅仅插入它） />在没有完全理解的情况下进入应用程序）并且因为，为了设计一个可重用的组件，必须事先知道将来使用的所有方法，如果不是这样的话，那就很困难了。 >不可能。
如果我们的程序员没有经验，我会把这归结为缺乏经验。但这是我们的编程小组的结论，
多年来使用各种语言（OOP，程序和功能）在许多平台上编写软件。虽然OOP肯定有它的位置（例如，它在编写实时电信软件时特别有用），但这个地方似乎并不是WWW
应用程序。我可以补充一点，我们的开发人员非常熟悉互联网标准和协议，这对于开发人员来说可能并非如此。
我们在WWW应用上的工作效率显着提高因为我们接受了这个令人惊讶的结论。还有其他商店结束了吗？其他ASP.NET开发人员的经验是什么？
Bob
inexperience. But this is the conclusion of our programming group,
which has written software on many platforms using various languages
(OOP, procedural, and functional) over many years. While OOP certainly
Probably too many years, and not willing to keep up.
Here''s the thing. Take DOS for example. No doubt you can write a program for
DOS that runs much faster than one written for Windows XP. There''s a heck of
a lot of overhead in creating a multitasking, multiuser, network Operating
System. But there are many good reasons why nobody uses DOS any more. There
are many good reasons for making ASP.net object-oriented. Too many, in fact,
to enumerate here. And sure, it''s uncomfortable to keep up with the latest
programming technologies. But if you don''t, you''ll be out of business if a
few short years.
--
HTH,
Kevin Spencer
..Net Developer
Microsoft MVP
Big things are made up
of lots of little things.
"parley" <pa**********@yahoo.com> wrote in message
news:8a**************************@posting.google.c om... After several years of programming WWW applications in ASP.NET (and
several other frameworks) our division has come to what might seem a
counterintiutive conclusion:
Writing ASP.NET code in a "procedural" manner (without webcontrols and
without utilizing OOP concepts in general) produces code that is
remarkably faster and more scalable. In general a "bare ASP.NET"
application outruns it''s OOPy counterpart by factors of 2 to 10.
Surprising side-effects are that the procedural version has reduced
memory requirements, is easier to maintain and it is easier to explain
and debug. While reusability was a goal in the OOPy versions, that
goal proved elusive, since a developer must be taught the intricacies
of any new reusable component he is given (he can''t merely plug it
into an application without understanding it fully) and because, to
design a reusable component one must know beforehand all the ways it
will be used in the future, something that is difficult if not
impossible.
If our programmers _were_ inexperienced, I would chalk this up to
inexperience. But this is the conclusion of our programming group,
which has written software on many platforms using various languages
(OOP, procedural, and functional) over many years. While OOP certainly
has it''s place (e.g., it is particularly useful in writing real-time
telecommunications software), that place does not seem to be WWW
applications. I might add that our developers are very familiar with
Internet standards and protocols, something that may not be true of
developers in general.
Our productivity on WWW apps has increased significantly since we
accepted this surprising conclusion. Have other shops concluded the
same? What are the experiences of other ASP.NET developers?
Bob
嗯，我知道我使用了一些OOP功能（继承）对于我的页面和我
知道使MUUUUCCCCHHH更快地开发和测试。至于
的表现，我没有对它进行过两次测试，所以我不能说。我的方式似乎很可能很快就会变得很快。任何性能损失，我正在采取我愿意花费b / b
，这样我只需几分钟就可以一起扔新页面
并测试它。
Michael
" parley" < PA ********** @ yahoo.com>在消息中写道
news：8a ************************** @ posting.google.c om ...
Well, I know that I use some OOP features (inheritance) for my pages and I
know that makes things MUUUUCCCCHHH faster to develop and test. As far as
performance, I''ve not tested it both way so I can''t say. My way seems
pretty darn fast as it is. Any performance loss that I''m taking I''m willing
to take so that it takes me just a few minutes to throw a new page together
and test it.
Michael
"parley" <pa**********@yahoo.com> wrote in message
news:8a**************************@posting.google.c om...
经过几年的ASP.NET编程WWW应用程序（以及其他几个框架），我们的部门已经看到了一个似乎是反作用的结论：
<在程序中编写ASP.NET代码方式（没有webcontrols和
，一般不使用OOP概念）产生的代码更快，更具可扩展性。一般来说，裸ASP.NET应用程序通过2到10的因子来表示它的OOPy对应物。
令人惊讶的副作用是程序版本减少了内存要求，更易于维护，更容易解释和调试。虽然可重用性是OOPy版本中的一个目标，但是这个目标被证明是难以捉摸的，因为开发人员必须学习他给出的任何新的可重用组件的复杂性（他不能仅仅插入它） />在没有完全理解的情况下进入应用程序）并且因为，为了设计一个可重用的组件，必须事先知道将来使用的所有方法，如果不是这样的话，那就很困难了。 >不可能。
如果我们的程序员没有经验，我会把这归结为缺乏经验。但这是我们的编程小组的结论，
多年来使用各种语言（OOP，程序和功能）在许多平台上编写软件。虽然OOP肯定有它的位置（例如，它在编写实时电信软件时特别有用），但这个地方似乎并不是WWW
应用程序。我可以补充一点，我们的开发人员非常熟悉互联网标准和协议，这对于开发人员来说可能并非如此。
我们在WWW应用上的工作效率显着提高因为我们接受了这个令人惊讶的结论。还有其他商店结束了吗？其他ASP.NET开发人员的经验是什么？
Bob
After several years of programming WWW applications in ASP.NET (and
several other frameworks) our division has come to what might seem a
counterintiutive conclusion:
Writing ASP.NET code in a "procedural" manner (without webcontrols and
without utilizing OOP concepts in general) produces code that is
remarkably faster and more scalable. In general a "bare ASP.NET"
application outruns it''s OOPy counterpart by factors of 2 to 10.
Surprising side-effects are that the procedural version has reduced
memory requirements, is easier to maintain and it is easier to explain
and debug. While reusability was a goal in the OOPy versions, that
goal proved elusive, since a developer must be taught the intricacies
of any new reusable component he is given (he can''t merely plug it
into an application without understanding it fully) and because, to
design a reusable component one must know beforehand all the ways it
will be used in the future, something that is difficult if not
impossible.
If our programmers _were_ inexperienced, I would chalk this up to
inexperience. But this is the conclusion of our programming group,
which has written software on many platforms using various languages
(OOP, procedural, and functional) over many years. While OOP certainly
has it''s place (e.g., it is particularly useful in writing real-time
telecommunications software), that place does not seem to be WWW
applications. I might add that our developers are very familiar with
Internet standards and protocols, something that may not be true of
developers in general.
Our productivity on WWW apps has increased significantly since we
accepted this surprising conclusion. Have other shops concluded the
same? What are the experiences of other ASP.NET developers?
Bob
---
外发邮件已通过无病毒认证。
由AVG反病毒系统检查（ http：//www.grisoft .com）。
版本：6.0.573 /病毒库：363 - 发布日期：2004年1月28日
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.573 / Virus Database: 363 - Release Date: 1/28/2004
这篇关于程序性[“裸ASP.NET”]与OOPy ASP.NET的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
