标签: late-binding

创建依赖注入绑定的两种常见机制(例如通过IOC容器)来自XML配置或命令式代码块.在这些情况下,键值对是显式的(即键=请求类型,值=返回类型).

仍然有第三种"启发式"方法,其中应用程序/ IOC容器仅被赋予[IMyClass]键,然后容器反映一组应用程序组件依赖项以查找所有名称匹配的具体类[MyClass].换句话说,发现"返回类型"值而不是声明.

我想知道的是双重的:

1. 哪些IOC容器(或其他后期绑定工具)允许启发式方法？这种方法有更常见的名称吗？
2. 是否有其他绑定技术,除了我列出的三个,在实践中使用？

我已经搜索了有关堆栈溢出的后期绑定的所有类似问题,我会严重不同意将此问题标记为重复的任何人.首先,我在另一个问题上找到了这个例子,但是我不明白在编译期间什么时候决定什么以及什么时候在运行时决定了什么我应该知道.基本上,我的问题的症结归结为两件事:

• 本例中的内容必须使我得出一个逻辑结论:一个方法是后期绑定,另一个方法是早期绑定

• 我如何知道在Java中运行时或编译时决定执行哪个版本的方法的决定

码:

class A
{
    public void foo()
    {
        System.out.println("Class A");
    }
}

class B extends A
{
    public void foo()
    {
        System.out.println("Class B");
    }
}

public class C
{
    public static void main(String [] args)
    {
        A a=new A();
        B b=new B();
        A ref=null;

        /* 
            early binding  --- calls method foo() of class A and
            decided at compile time
        */ 
         a.foo(); 

        /* early binding --- calls method foo() of class B and
            decided at compile …

我有一个关于C++双重调度的问题.在下面的代码中,我希望第二组的结果与第一组的结果相匹配.

我不知道实际的类型(除非我尝试dynamic_cast)但我知道该对象继承自BaseClass类型.实现这一目标的最有效(性能)方法是什么？

谷歌搜索了一段时间后,我发现了双重调度和loki多方法.我在Shape示例中遇到的问题是,在我的应用程序中,Processor和BaseClass完全独立,并且没有可以相互调用的常用方法.其次,只有一个处理器(即没有从它继承).

谢谢你的帮助.

#include <iostream>
#include <string>
using namespace std;

class BaseClass{
public:
       BaseClass(){}
       virtual void myFunction(){cout << "base myFunction called" << endl;}
};

class Derived1: public BaseClass{
public:
       Derived1():BaseClass(){}
       void myFunction(){cout << "Derived1 myFunction called" << endl;}
};


class Derived2: public BaseClass{
public:
       Derived2():BaseClass(){}
       void myFunction(){cout << "Derived2 myFunction called" << endl;}
};

class Derived3: public BaseClass{
public:
       Derived3():BaseClass(){}
       void myFunction(){cout << "Derived3 myFunction called" << endl;}

};

class Processor{
public:
       Processor(){}
       virtual void processObj(BaseClass* bc){cout << "got …

有没有办法禁止在.net 4中使用"dynamic"关键字？

我认为如果使用动态关键字,VS2010的代码分析功能可能有一个规则使构建失败,但我不能解决问题.

我有一个程序,我开发使用基本的插件架构.实际上,当程序加载时,它使用反射在目录中搜索适合某个接口的dll,然后加载它们.现在看来,当前的插件列表将被使用.

因此,我目前检查dll文件的做法仍然是最佳做法,还是有更好的方法来加载每个dll？

谢谢.

我有以下代码:

class Pet {
public:
  virtual string speak() const { return ""; }
};

class Dog : public Pet {
public:
  string speak() const { return "Bark!"; }
};

int main() {
  Dog ralph;
  Pet* p1 = &ralph;
  Pet& p2 = ralph;
  Pet p3;

  // Late binding for both:
  cout << "p1->speak() = " << p1->speak() <<endl;
  cout << "p2.speak() = " << p2.speak() << endl;

  // Early binding (probably):
  cout << "p3.speak() = " << p3.speak() << endl;
} …

我有一个后期绑定的COM对象(My.COMInterface),它在完成处理时引发一个事件.如何从VB6代码中使用该事件？

如果我是早期绑定,我会将我的COM对象声明为WithEvents,并编写一个普通的事件处理程序.如何使用后期绑定实现此目的？

当前代码:

Dim comObject as Object

'Function to launch Process.
Public Function LaunchProcess() As Boolean
    Set comObject = CreateObject("My.COMInterface")

    LaunchProcess= comObject.CallProcess()
    ' Once this process has finished, it will raise an event 
    ' called ProcessingFinished - how do I consume it?
End Function

我目前知道的唯一方法是编写一个C/C++桥来处理事件,如本MSDN文章中所述.我希望有一个更简单的方法!

首先,对不起标题,我找不到更好的一个.

以下代码是我在Python程序中遇到的问题的最小化版本(我是新手btw.).

def onClick(i):
    print "This is Button: " + str(i)
    return

def start():
    b = [0 for x in range(5)]
    win = Tkinter.Tk()
    for i in range(5):
        b[i] = Tkinter.Button(win,height=10,width=100,command=lambda : onClick(i))
        b[i].pack()
    return

它的作用:无论我点击什么按钮,它都会显示"这是按钮:4".

我想要的是:第一个按钮应该说"这是按钮:0"等等.

这是Python的通缉行为吗？如果答案是肯定的,为什么会这样呢？我该如何解决？

另一方面,这很好用:

def start():        
    x = [0 for x in range(5)]
    for i in range(5):
        x[i] = lambda:onClick(i)
        x[i]()
    return

我已经看到两者互换使用,但他们真的是一样的意思吗？根据我的理解,Polymorphism延伸了这样一个事实:你可以通过子类的实例交换类的实例,而Late Binding意味着当你调用实例的方法时,类型决定调用哪个方法(子类/超类) .

我读了一个关于多态的例子,它看起来像波纹管,其中show()是一个虚函数:

int main()
{
  Derived dv1;
  Derived dv2;
  Base* ptr;

  ptr = &dv1;
  ptr->show();

  ptr = &dv2;
  ptr->show();
}

书中说,在这种情况下,编译器将使用late binding技术.我确实理解后期绑定和早期绑定之间的区别.但是,在这个例子中,我们(也可能是编译器)可以看到应该调用哪个函数,因为ptr指向的对象没有变化.那么为什么不在这种情况下提前绑定,因为后期绑定会导致一些开销？