blocks|key|2031267|text|除了让读者感到困惑之外，我看不出这样做有什么好处。关于我的同伴回答，我想知道这是在哪个星球上更具可读性。据我所知，第一个版本或多或少具有完美的可读性，而这是相当可读的，但这会让读者怀疑With和WithIf中是否发生了一些奇怪的魔术。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2031268|与第一个版本相比，它更长，更难输入，不那么明显，性能也更差。|2031269|entityMap^0|2K|4|2P|6|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

I see no advantage to this besides being confusing to the reader. With respect to my fellow answerer, I would like to know on what planet this is more readable. As far as I can tell, the first version has more or less perfect readability, whereas this is fairly readable, but makes the reader wonder whether there's some strange magic happening within <code>With</code> and <code>WithIf</code>.

Compared to the first version, it's longer, harder to type, less obvious, and less performant.

blocks|key|2031285|text|这是我见过的一些扩展方法的滥用！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031286|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

That is some extension method abuse if I ever saw it!

blocks|key|2031300|text|我想我看不出新版本给你带来了什么。原文写得很清楚，也没那么冗长。我猜它也会更快。我会避免使用(滥用？)这样的语言特性，除非有明显的好处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031301|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I guess I fail to see what the new versions get you. The original is pretty clear and is less wordy. I would guess that it would be faster as well. I would avoid using (abusing?) language features like this unless there is a clear benefit.

blocks|key|1817820|text|他们只是不同的编码风格，你说的“太大的偏离”是什么意思？背离什么？从你所习惯的？只有你才能决定。我会说VB的With代码块对代码的可读性弊大于利，我不会尝试在C#中复制这种行为，但这只是我的偏好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1817821|我几乎总是对FindControl使用它(是的，强类型到RepeaterItem，它不是必须的，但这是我唯一用过的东西)：|1817822|public+static+T+FindControl<T>(this+RepeaterItem+item,+string+id)+
{
++++return+item.FindControl(id)+as+T;
}|code-block|syntax|javascript|1817823|并像这样调用它：|1817824|Literal+myLiteral+=+e.Item.FindControl<Literal>("myLiteral");|1817825|entityMap^0|1I|4|0|6|B|S|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

They're just different coding styles, what do you mean by "too big a departure"? Departure from what? From what you're used to? Only you can decide that. I will say that VB's <code>With</code> block has done more harm than good to code readability, and I would not try to replicate the behavior in C#, but that's just my preference.

I pretty much always use this for <code>FindControl</code> (yeah, strongly typed to <code>RepeaterItem</code>, it doesn't have to be, but that's the only thing I ever use it for anyway):

<pre><code>public static T FindControl&lt;T&gt;(this RepeaterItem item, string id) 
{
 return item.FindControl(id) as T;
}
</code></pre>

And invoke it like so:

<pre><code>Literal myLiteral = e.Item.FindControl&lt;Literal&gt;("myLiteral");
</code></pre>

blocks|key|1817842|text|我的2点意见:它看起来很好，我唯一的评论是，当你实际设置一个属性时，"With“有点像"Where”或“that”。我建议使用类似于"Do“、"Execute”或"Set“的方法名，但这可能只是我奇怪的世界观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817843|这样如何：|1817844|Page.WithControl<DropDownList>("LocationDropDownList")
++++.Do(d+=>+d.Visible+=+true)
++++.Do(d+=>+d.SelectedValue+=+"123")
++++.DoIf(isAdmin,+d+=>+d.Items.Add(new+ListItem("Admin",+"1")));|code-block|syntax|javascript|1817845|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My 2 cents: It looks fine, my only comment is that "With" kind of implies something like "Where" or "Having" when you are actually setting a property. I'd suggest a method name of something like "Do", "Execute" or "Set" but maybe thats just my odd world view.

How about:

<pre><code>Page.WithControl&lt;DropDownList&gt;("LocationDropDownList")
 .Do(d =&gt; d.Visible = true)
 .Do(d =&gt; d.SelectedValue = "123")
 .DoIf(isAdmin, d =&gt; d.Items.Add(new ListItem("Admin", "1")));
</code></pre>

blocks|key|1817859|text|我说坚持使用第一个版本，没有扩展方法或lamba表达式。这些都是相对较新的概念，因此除了用于从数据库中检索/操作数据之外，还没有多少开发人员能够掌握它们。如果你使用它们，你可能会降低维护成本。说“如果这对你来说是希腊语，读一读”是很好的；但在现实生活中，这可能是最好的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817860|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I say stick with the first version without the extension methods or lamba expressions. These are relatively new concepts so not many developers will have a handle on them yet outside their use in data retrieval/manipulation from a database. If you use them you may have a hit on maintenance cost. It is nice to say "read up if this is Greek to you"; but in real-life that may be the best approach.

blocks|key|1817881|text|我更喜欢第一个版本。阅读和理解所需的时间更短。我同意，如果您熟悉扩展方法并熟悉with方法，那么扩展方法也很好，但是在这种情况下，它有什么好处呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817882|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I am more comfortable with the first version. It takes less time to read and understand. I agree that the extension methods are also fine if you are familiar with it and also familiar with the With method, but what’s the benefit of it in this case?

blocks|key|1817891|text|这是扩展的一个有趣的用法，我很欣赏它的优点。我不确定我是否会使用它，但如果您的团队喜欢它，那么一定要使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817892|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It's an interesting use of extensions, and I appreciate it on that merit alone. I'm not sure I'd use it, but if your team likes it, then by all means, use it.

blocks|key|2031389|text|再投一票给“没用的”。With扩展方法除了用一个方法包装已排序的语句之外，什么也不做。C#已经有了一个内置的语句排序函数，它的名字叫;。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2031390|类似地，WithIf包装了一个if语句，而不对控制流进行任何修改。在我看来，您只会邀请自己使用以下方法：|2031391|public+static+T+For<T>(
++++this+T+t,+int+start,+Func<int,+bool>+cond,+Action<T,+int>+f)
{
++++for(int+i+=+start;+cond(i);+i%2B%2B)
++++{
++++++++f(t,+i);
++++}
++++return+t;
}|code-block|syntax|javascript|2031392|entityMap^0|B|4|1U|1|0|4|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

One more vote for "not useful". The <code>With</code> extension method doesn't do anything except wrap up sequenced statements with a method. C# already already has a built-in function for sequencing statements, its called <code>;</code>.

Similarly, the <code>WithIf</code> wraps an if-statement without any modification to the control flow. From my point of view, you're only inviting yourself to methods like:

<pre><code>public static T For&lt;T&gt;(
 this T t, int start, Func&lt;int, bool&gt; cond, Action&lt;T, int&gt; f)
{
 for(int i = start; cond(i); i++)
 {
 f(t, i);
 }
 return t;
}
</code></pre>

blocks|key|2031410|text|我会说坚持使用第一个版本。你发布的内容太聪明了，对阅读代码的人来说不会立即有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031411|你甚至可以更进一步，去掉这个"var"：|2031412|DropDownList+ddl+=+(DropDownList)+Page.FindControl("ddlName");|code-block|syntax|javascript|2031413|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'd say stick with the first version. What you've posted is too clever to be immediately useful to someone reading the code.

You could even go a step further and do away with that "var":

<pre><code>DropDownList ddl = (DropDownList) Page.FindControl("ddlName");
</code></pre>

blocks|key|1817956|text|我预测整个“流畅界面”的时尚将是2000年代的“匈牙利符号”，我个人认为它看起来不是很干净，如果你有多个开发人员，每个人都有自己的偏好，那么它就有变得非常不一致的风险。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817957|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I predict the whole "fluent interface" fad will be the "hungarian notation" of the 2000's. I personally think it doesn't look very clean and it runs the risk of becoming very inconsistent if you have multiple developers each with their own preference.

blocks|key|1817967|text|原版的可读性更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817968|最简单的API更改是使FindControl()返回的对象成为构建器风格的东西(其中所有的set方法都返回'this')：|1817969|Page.FindControl("LocationDropDownList")
++++.setVisible(true)
++++.setSelectedValue(isAdmin+?+"111"+:+"123");|code-block|syntax|javascript|1817970|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The original is more readable.

The simplest API change would be to make the object returned by FindControl() a Builder-esque thing (where all the set methods return 'this'):

<pre><code>Page.FindControl("LocationDropDownList")
 .setVisible(true)
 .setSelectedValue(isAdmin ? "111" : "123");
</code></pre>

blocks|key|1817984|text|看起来你的同事是个兰布达怪胎。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1817985|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Looks like your co worker is a Lambda Junkie.

blocks|key|2031462|text|我认为可读性的问题是主观的，我个人对你所做的没有任何问题。如果你的组织“认可”它，我会考虑使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031463|我认为这个概念是合理的，如果你将"With“改为"Let”，它将更具“功能性”或"F#-ish“。个人观点。|2031464|Page.FindControl("LocationDropDownList")++++
++++.CastAs<DropDownList>()++++
++++.Let(d+=>+d.Visible+=+true)++
++++.Let(d+=>+d.SelectedValue+=+"123");|code-block|syntax|javascript|2031465|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think the question of readability is subjective and I personally have no issue with what you've done. I would consider using it if your organization "approved" it. 

I think the concept is sound and if you changed "With" to "Let" it would be more "functional" or "F#-ish". Personal opinion.

<pre><code>Page.FindControl("LocationDropDownList") 
 .CastAs&lt;DropDownList&gt;() 
 .Let(d =&gt; d.Visible = true) 
 .Let(d =&gt; d.SelectedValue = "123");
</code></pre>

blocks|key|1817999|text|小音符。从个人经验来看，我会改变：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1818000|if(isAdmin)
++++ddl.SelectedValue+=+"111";|code-block|syntax|javascript|1818001|至|1818002|if(isAdmin)+{
++++ddl.SelectedValue+=+"111";
}|1818003|或|1818004|if(isAdmin)+
{
++++ddl.SelectedValue+=+"111";
}|1818005|这迟早会节省你的调试时间。|1818006|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Minor note. From personal experience, I'd change:

<pre><code>if(isAdmin)
 ddl.SelectedValue = "111";
</code></pre>

to 

<pre><code>if(isAdmin) {
 ddl.SelectedValue = "111";
}
</code></pre>

or

<pre><code>if(isAdmin) 
{
 ddl.SelectedValue = "111";
}
</code></pre>

This will save you time in debugging sooner or later.

blocks|key|1818020|text|这是一个完美的学习案例，教你如何让事情变得比需要的更复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1818021|第一个版本很清楚，除了正常的语言结构外，不需要额外的知识。|1818022|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This is a perfect learning case on how to make something more complicated than it needs to be.

The first version is clear and requires no extra knowledge beyond normal language contructs.

blocks|key|2031504|text|关于“流畅的接口”，C#已经有了一个很好的初始化器语法，这比尝试使用流畅的风格要好得多。当然，在您的示例中，您不是在初始化一个新对象，而是在更改一个现有对象。我对流利界面的全部专业知识都来自于对wikipedia的30秒扫描，但我认为JeeBee的答案更多地体现了流利编程的精神，尽管我可能会稍微改变一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2031505|Page.FindDropDownList("LocationDropDownList")++++
++.setVisible(true)++++
++.setAdminSelectedValue("111")
++.setSelectedValue("123")|code-block|syntax|javascript|2031506|有人可能会争辩说，这更具可读性，特别是对于没有属性的语言，但我仍然认为它在C#中没有意义。|2031507|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fluent_interface^0|2P|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Regarding a "Fluent Interface" C# already has a great syntax for initializers which is (IMHO) better that trying to use the fluent style. Of course, in your example you are not initializing an new object, you are changing an existing one. My whole expertise with Fluent interfaces comes from a 30 second scan of <a href="http://en.wikipedia.org/wiki/Fluent_interface" rel="nofollow noreferrer">wikipedia</a>, but I think that JeeBee's answer is more in the spirit of Fluent programming, though I might change things slightly:

<pre><code>Page.FindDropDownList("LocationDropDownList") 
 .setVisible(true) 
 .setAdminSelectedValue("111")
 .setSelectedValue("123")
</code></pre>

One could argue that this is more readable, especially for a language without Properties, but I still think it doesn't make sense in C#.

blocks|key|2031524|text|在某些情况下，经过深思熟虑地构造流畅的接口可能非常有用。首先，由于呈现给开发人员的选项数量有限，它们(通常)很容易正确使用，但很难错误地使用。其次，因为它们像句子一样的结构，所以它们可以很好地清晰地表明你的意图，特别是在构建复杂对象时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2031525|我发现在开发测试代码时，流畅的接口非常有用，在测试代码中，经常需要构建许多具有微小变化的域对象。我还成功地将它们用作引入装饰器模式和消除过多方法重载的一种方法。|2031526|如果任何人有兴趣学习更多关于流畅界面的知识，我建议你看看Martin+Fowler写的这篇work+in+progress。|offset|length|2031527|entityMap|0|LINK|mutability|MUTABLE|url|http://martinfowler.com/bliki/FluentInterface.html^0|0|0|19|G|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

In certain circumstances thoughtfully constructed fluent interfaces can be very useful. First, because the developer is presented with a limited number of options they are (typically) easy to use correctly and difficult to use incorrectly. Second, because of the sentence like structure they can be a nice clean way to declare your intentions, especially when building complex objects.

I have found fluent interfaces to be very useful when developing test code in which it is often necessary to build lots of domain objects with slight variations. I have also used them successfully as a way to introduce the decorator pattern and to eliminate excessive method overloading.

If anyone is interested in learning more about fluent interfaces, I suggest checking out this <a href="http://martinfowler.com/bliki/FluentInterface.html" rel="nofollow noreferrer">work in progress</a> by Martin Fowler.

A co-worker of mine came up with this and I wonder what others think? Personally, I find it interesting but wonder if it is too big a departure? Code examples below. Extension methods at the bottom.

General thoughts please. Other extension methods that could be added?

<pre><code>var ddl = Page.FindControl("LocationDropDownList") as DropDownList;

ddl.Visible = true;
ddl.SelectedValue = "123";

if(isAdmin)
 ddl .SelectedValue = "111";
</code></pre>

Becomes:

<pre><code>Page.FindControl("LocationDropDownList")
 .CastAs&lt;DropDownList&gt;()
 .With(d =&gt; d.Visible = true)
 .With(d =&gt; d.SelectedValue = "123")
 .WithIf(isAdmin, d =&gt; d.Items.Add(new ListItem("Admin", "1")));
</code></pre>

Or:

<pre><code> Page.FindControl("LocationDropDownList")
 .CastAs&lt;DropDownList&gt;()
 .With(d =&gt;
 {
 d.Visible = true;
 d.SelectedValue = "123";
 })
 .WithIf(isAdmin, d =&gt; d.SelectedValue = "111");
</code></pre>

Extension methods:

<pre><code>public static TResult CastAs&lt;TResult&gt;(this object obj) where TResult : class
{
 return obj as TResult;
}

public static T With&lt;T&gt;(this T t, Action&lt;T&gt; action)
{
 if (action == null)
 throw new ArgumentNullException("action");

 action(t);

 return t;
}

public static T WithIf&lt;T&gt;(this T t, bool condition, Action&lt;T&gt; action)
{
 if (action == null)
 throw new ArgumentNullException("action");

 if (condition)
 action(t);

 return t;
}
</code></pre>

More fluent C# / .NET

数据库

我的一个同事提出了这个想法，我想知道其他人是怎么想的？就我个人而言，我觉得这很有趣，但我想知道这是不是太偏离了？下面是代码示例。底部的扩展方法。请给我一个大概的想法。还可以添加其他扩展方法吗？var ddl = Page.FindControl("LocationDropDownList") as DropDownLi...

问更流畅的C# / .NET
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更流畅的C# / .NETEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问更流畅的C# / .NET
EN