blocks|key|5453711|text|使用委托？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5453712|http://msdn.microsoft.com/en-us/library/ms173171%2528v=vs.80%2529.aspx|offset|length|5453713|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms173171%2528v=vs.80%2529.aspx^0|0|0|1U|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Use delegates?

<a href="http://msdn.microsoft.com/en-us/library/ms173171%28v=vs.80%29.aspx" rel="nofollow">http://msdn.microsoft.com/en-us/library/ms173171%28v=vs.80%29.aspx</a>

blocks|key|3984748|text|使用func+Func<T,+TResult>+link|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3984749|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb549151.aspx^0|7|G|O|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

use func <code>Func&lt;T, TResult&gt;</code>
<a href="http://msdn.microsoft.com/en-us/library/bb549151.aspx" rel="nofollow">link</a>

blocks|key|5453749|text|最简单的方法是传递URI而不是引用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5453750|例如，"NS.Child.ThirdMethod“。|5453751|否则，委托是最接近函数引用的对象。如果你愿意，你可以通过它。|5453752|然而，这种方法不符合OOP概念规则:基类应该对其子类一无所知。最好使用某种锁定机制来告诉孩子，他们不能访问资源。|5453753|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The easiest way is to pass an URI instead of a reference:

"NS.Child.ThirdMethod" for example.

Otherwise, a delegate is what is the closest to a function reference. You can pass that if you want.

However, this method is not compliant with OOP conception rules: Base class should know nothing about its children classes. 
It's better to use some kind of locking mechanism to tell the children that they can't have access to the resources.

blocks|key|1668690|text|注意:我是在回答你的问题，而不是你的标题。其他人已经回答了标题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668691|有些对象有一个isDisposed属性，如果你的父对象实现了这个属性，并且这是你唯一不想调用方法的时候，那么可以。否则就不会。如果您控制了父对象的源代码，则可以添加一个执行所需操作的属性。|1668692|如果您不控制源代码，并且希望检查不止isDisposed，或者父对象没有实现isDisposed，那么您也许能够检查公开的属性，但通常您应该假设，如果一个方法向公众公开，则可以在任何时候调用它。如果你通过反射调用私有方法，那么你就是在冒险。|1668693|响应注释编辑：根据你的描述，委托不会给你任何额外的功能，你不能通过向父代理添加属性和方法来更容易地完成这些功能(如果你不控制源代码，它们根本不会有帮助)。处理您所描述的场景的最佳方法(CAR.ENGINE.START当汽油耗尽时，启动方法要么抛出异常，要么返回一个指示尝试启动引擎的结果的值)。|offset|length|style|BOLD|1668694|entityMap^0|0|0|0|0|7|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@$H|R|I|S|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Note: I am answering your question, not your title. Others have answered the title.

Some objects have an isDisposed property, if your parent implements that and that is the only time you don't want to call methods, then yes. Otherwise no. If you control the source for the parent, you could add a property that does what you want.

If you don't control the source and you want to check more than isDisposed or the parent doesn't implement isDisposed, you might be able to check publicly exposed properties, but generally you should assume that if a method is exposed to the public, that it is acceptable to call it at any time. If you're calling private methods via reflection, then you're taking chances.

Edit in response to comment:
Given your description, delegates won't give you any additional capability that you can't do easier by adding properties and methods to the parent (if you don't control the source, they won't help at all). The best method for dealing with your described scenario (CAR.ENGINE.START when out of gas, is for the Start method to either throw an exception or return a value indicationg the result of the attempt to start the engine).

blocks|key|3984857|text|如果这些方法是子类的原生方法，那么父类就不能确定任何关于它们的信息。Rice's+Theorem会给你带来各种各样的问题，如果你能看到代码的话。如果它们是父类的原生类并且在子类中被覆盖，那么也会出现同样的问题(但程度较小)，因为您不能真正保证子类将做父类所做的所有事情(并且只做那些事情)；实际上，您几乎可以保证它会做一些不同的事情。(如果没有，为什么要重写呢？)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3984858|如果它们是父类原生的，并且在子类中不可重写，那么只需检查对象是否处于执行此类操作的有效状态，如果不是，则抛出异常。|3984859|就实际的有效性检查而言，对于您的示例，您可以使用像bool+IsDisposing()这样的方法；对于其他情况，您可能会以其他方式跟踪状态。例如，像CanDoThisThing()这样的私有方法可能会有所帮助。在我看来，有一个接受泛型操作名称的方法(不是操作；我们已经确定了它的不可行性)似乎有点问题。|style|CODE|3984860|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Rice%2527s_theorem^0|Y|E|0|0|0|P|I|22|G|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@$A|X|B|Y|H|I]|$A|Z|B|10|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

If these methods are native to the child class, the parent can't know anything about them for sure. <a href="http://en.wikipedia.org/wiki/Rice%27s_theorem" rel="nofollow">Rice's Theorem</a> will cause you all kinds of problems, if you could even see the code. Same problem (but to a lesser degree) if they're native to the parent class and are being overridden in the child, since you can't really guarantee that the child class will be doing everything (and only those things) that the parent class does; in fact, you can all but guarantee it will do something different. (If it didn't, why override?)

If they're native to the parent class and not overridable in the child, then just check whether the object is in a valid state for doing such a thing and throw an exception if it isn't.

As far as the actual validity check, for your example you can have a method like <code>bool IsDisposing()</code>; for other cases, you might keep track of the state in some other way. A private method like <code>CanDoThisThing()</code> might help, for example. Having a method that takes a generic operation name (not an operation; we already established the infeasibility of that) seems kinda broken to me.

blocks|key|3984874|text|再次感谢大家，第一种方法的结果如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3984875|public+class+Component
{
++++public+ComponentPart+SomeComponentPart1+{+get;+private+set;+}
++++public+ComponentPart+SomeComponentPart2+{+get;+private+set;+}

++++public+Component()
++++{
++++++++SomeComponentPart1+=+new+ComponentPart(this);
++++++++SomeComponentPart2+=+new+ComponentPart(this);
++++}

++++public+bool+IsMethodCallAcceptable(MethodCallExpression+method,+object[]+parameters)
++++{
++++++++//+collect+needed+information+about+caller
++++++++var+caller+=+(method.Object+as+ConstantExpression).Value;
++++++++var+methodName+=+method.Method.Name;
++++++++var+paramsArray+=+new+Dictionary<string,+object>();

++++++++for+(int+i+=+0;+i+<+method.Arguments.Count;+i%2B%2B)
++++++++++++paramsArray.Add((method.Arguments[i]+as+MemberExpression).Member.Name,+parameters[i]);

++++++++//+make+corresponding+decisions
++++++++if+(caller+==+SomeComponentPart2)
++++++++++++if+(methodName+==+"SomeMethod")
++++++++++++++++if+((int)+paramsArray["intArg"]+==+0+%7C%7C+(string)+paramsArray["stringArg"]+==+"")
++++++++++++++++++++return+false;

++++++++return+true;
++++}
}

public+class+ComponentPart
{
++++private+Component+Owner+{+get;+set;+}

++++public+ComponentPart(Component+owner)
++++{
++++++++Owner+=+owner;
++++}

++++public+int+SomeMethod(int+intArg,+string+stringArg)
++++{
++++++++//+check+if+the+method+call+with+provided+parameters+is+acceptable
++++++++Expression<Func<int,+string,+int>>+expr+=+(i,+s)+=>+SomeMethod(intArg,+stringArg);
++++++++if+(!Owner.IsMethodCallAcceptable(expr.Body+as+MethodCallExpression,+new+object[]+{+intArg,+stringArg+}))
++++++++++++throw+new+Exception();

++++++++//+do+some+work
++++++++return+stringArg.Length+%2B+intArg;
++++}

++++public+void+AnotherMethod(bool+boolArg,+Dictionary<Guid,+DateTime>+crazyArg,+string+stringArg,+object+objectArg)
++++{
++++++++//+check+if+the+method+call+with+provided+parameters+is+acceptable
++++++++Expression<Action<bool,+Dictionary<Guid,+DateTime>,+string,+object>>+expr+=
++++++++++++(b,+times,+arg3,+arg4)+=>+AnotherMethod(boolArg,+crazyArg,+stringArg,+objectArg);
++++++++if+(!Owner.IsMethodCallAcceptable(expr.Body+as+MethodCallExpression,+new+[]+{+boolArg,+crazyArg,+stringArg,+objectArg+}))
++++++++++++throw+new+Exception();

++++++++//+do+some+work
++++++++var+g+=+new+Guid();
++++++++var+d+=+DateTime.UtcNow;
++++}
}|code-block|syntax|javascript|3984876|这是检查方法调用的不同方法，可以使用相同的方法来检查属性值的更改，而一些ComponentPart的方法和属性可以检查一些公共Component.State属性(通过ComponentPart.Owner)，而不是调用Component.IsMethodCallAcceptable或Component.IsPropertyChangeAcceptable。|3984877|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Thank you all again, the result in the first approach is listed below

<pre><code>public class Component
{
 public ComponentPart SomeComponentPart1 { get; private set; }
 public ComponentPart SomeComponentPart2 { get; private set; }

 public Component()
 {
 SomeComponentPart1 = new ComponentPart(this);
 SomeComponentPart2 = new ComponentPart(this);
 }

 public bool IsMethodCallAcceptable(MethodCallExpression method, object[] parameters)
 {
 // collect needed information about caller
 var caller = (method.Object as ConstantExpression).Value;
 var methodName = method.Method.Name;
 var paramsArray = new Dictionary&lt;string, object&gt;();

 for (int i = 0; i &lt; method.Arguments.Count; i++)
 paramsArray.Add((method.Arguments[i] as MemberExpression).Member.Name, parameters[i]);

 // make corresponding decisions
 if (caller == SomeComponentPart2)
 if (methodName == "SomeMethod")
 if ((int) paramsArray["intArg"] == 0 || (string) paramsArray["stringArg"] == "")
 return false;

 return true;
 }
}

public class ComponentPart
{
 private Component Owner { get; set; }

 public ComponentPart(Component owner)
 {
 Owner = owner;
 }

 public int SomeMethod(int intArg, string stringArg)
 {
 // check if the method call with provided parameters is acceptable
 Expression&lt;Func&lt;int, string, int&gt;&gt; expr = (i, s) =&gt; SomeMethod(intArg, stringArg);
 if (!Owner.IsMethodCallAcceptable(expr.Body as MethodCallExpression, new object[] { intArg, stringArg }))
 throw new Exception();

 // do some work
 return stringArg.Length + intArg;
 }

 public void AnotherMethod(bool boolArg, Dictionary&lt;Guid, DateTime&gt; crazyArg, string stringArg, object objectArg)
 {
 // check if the method call with provided parameters is acceptable
 Expression&lt;Action&lt;bool, Dictionary&lt;Guid, DateTime&gt;, string, object&gt;&gt; expr =
 (b, times, arg3, arg4) =&gt; AnotherMethod(boolArg, crazyArg, stringArg, objectArg);
 if (!Owner.IsMethodCallAcceptable(expr.Body as MethodCallExpression, new [] { boolArg, crazyArg, stringArg, objectArg }))
 throw new Exception();

 // do some work
 var g = new Guid();
 var d = DateTime.UtcNow;
 }
}
</code></pre>

This is variant how to check method calls, the same approach can be used in order to check properties values changes, while some ComponentPart' methods and properties can check some public Component.State property (via ComponentPart.Owner) instead of calling Component.IsMethodCallAcceptable or Component.IsPropertyChangeAcceptable.

I need to examine in "parent" object is there an acceptable at a definite moment to call some method in the "child". For example, parent object (component) includes child objects (or component parts in other words) and parent is disposing now, so all (or particlar) child activities must be prohibited (i.e. starting new service threads, enqueueing new client requests, ...).

<pre><code>public class Parent
{
 public bool IsMethodCallAcceptable(reference_to_method) {...}
}

public class Child
{
 public int SomeMethod(int intArg, string stringArg)
 {
 if(!_parent.IsMethodCallAcceptable(reference_to_SomeMethod_with_actual_args))
 throw new ...
 ...
 }

 private void AnotherMethod(string param = null) {...}
 {
 if(!_parent.IsMethodCallAcceptable(reference_to_AnotherMethod_with_actual_args))
 throw new ...
 ...
 }

 private Guid ThirdMethod()
 {
 if(!_parent.IsMethodCallAcceptable(reference_to_ThirdMethod))
 throw new ...
 ... 
 }
}
</code></pre>

Is there any way to do it?

How to pass method as a parameter for another method

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要检查在"parent“对象中，是否有一个可以接受的方法在某个特定时刻调用”孩子“中的某个方法。例如，父对象(组件)包含子对象(换句话说就是组件部分)，而父对象现在正在释放，因此必须禁止所有(或部分)子活动(即启动新服务线程、排队新客户端请求等)。public class Parent{    public boo...

问如何将方法作为另一个方法的参数传递
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将方法作为另一个方法的参数传递EN