标签: late-binding

我正在c#中开发一些代码,我将与Microsoft Word进行交互.我希望能够选择重新使用现有实例,或者作为创建新实例的替代方法.

请记住,我想使用LATE BINDING完成所有这些...可以肯定地说我已经弄清楚如何在创建新实例时让事情正常工作..我只需要调用Activator.CreateInstance等.

我遇到的问题是如何重用现有实例,例如,Word已经打开,我想使用该实例.

有没有Activator.UseExistingInstance？或者类似的东西？

谢谢!

以下代码是后期绑定test()方法,但不应该提前绑定？因为test()方法在B类中不是虚拟的(但在A类中),我们使用的是B类的指针.

class A{
    public:
        virtual void test(){
            cout<<"test a";
        }
};
class B : public A{
    public:
        void test(){
            cout<<"Test b";
        }
};
class C: public B{
    public:
        void test(){
            cout<<"test c";
        }
};
int main(){
    B *bp;
    C objc;
    bp = &objc;
    bp->test();  // test c
}

正如"四人帮"在" 设计模式 "中所述:" 人们经常说 '继承打破了封装'",在"面向对象编程语言中的封装和继承"中解释Snyder.

然而,每次我读" 继承断裂包封 ",这要求背后的原因要么依稀解释的,或与所述的一个例子说明脆基类的问题.

在阅读论文时,我感觉真正打破封装的唯一继承属性是downcalls,这是开放递归(动态调度打开this)允许的特性,并定义为"当超类方法调用在子类中重写的方法时",根据Ruby&Leavens在"安全地创建正确的子类而不看超类代码"中的说法.
此外,根据Aldrich在"选择性开放递归:脆弱基类问题的解决方案"中的说法,开放递归显然是导致脆弱基类问题的原因.

因此,如果脆弱基类问题是"继承打破封装"的唯一原因,那么可以更清楚地说,下调会破坏封装.由于存在一些解决方案以避免在使用继承时进行下调,因此继承本身并不真正涉及破坏封装.此外,四人帮提出的取消继承的委托模式也可以允许开放递归和下调,因为委托人的context(this)由委托使用(这可能导致一种脆弱的委托类问题).

因此,我的问题是:
脆弱的基类问题是否被称为"继承打破封装"的唯一原因？

我有这段代码运行得很好，并为我提供了用户开始菜单的路径：

    Dim oShell As Object = CreateObject("Shell.Application")
    MsgBox(oShell.NameSpace(11).Self.Path)

这显然使用了后期绑定。现在假设我想在 C# 或 VB.NET 严格模式中执行此操作，这两种模式都不支持这种带有后期绑定的语法。

这可能吗？如何？

谢谢你的帮助！

我动态生成一个表单:

form = forms.Form()
form.fields['myname'] = forms.CharField(label=u'My Name')
...

然后显示表单:

buf = '....<form action="." method="POST">...' + form.as_p() + '...'
t = Template(buf)
v = RequestContext(request, {'form': form})
html = t.render(v)
...

通过将第一行更改为,我可以得到一个绑定的实例

form = forms.Form(request.POST)

在我开始生成动态表单之前.

但是,有没有办法保持动态表单生成代码,然后将表单绑定到request.POST数据？

谢谢

我在该类中有一个通用类我已经编写了一个方法,它应该接受object类的对象作为参数.

功能如下 -

protected void AddNewForm(object o )
{
    try
    {
        o.Show();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

我正在从另一个类调用此函数.但当我把这个功能称为 -

Contact objContact=new Contact(); 
AddNewForm(objContact);

但它显示该函数中的错误.错误如下 -

'object'不包含'Show'的定义,也没有扩展方法'Show'接受'object'类型的第一个参数(你是否缺少using指令或汇编引用？)

如何在C#windows应用程序中实现后期绑定？

谢谢.

我有一个 DLL，它的 h 文件中有这个：

extern "C" __declspec(dllexport) bool Connect();

并在c文件中：

extern "C" __declspec(dllexport) bool Connect()
{
     return false;  
}

在 C# 中，我有以下代码：

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate bool ConnectDelegate();

private ConnectDelegate DLLConnect;

public bool Connect()
{
    bool l_bResult = DLLConnect();
    return l_bResult;
}

public bool LoadPlugin(string a_sFilename)
{
   string l_sDLLPath = AppDomain.CurrentDomain.BaseDirectory;

   m_pDLLHandle = LoadLibrary(a_sFilename);
   DLLConnect = (ConnectDelegate)GetDelegate("Connect", typeof(ConnectDelegate));
   return false;
}

private Delegate GetDelegate(string a_sProcName, Type a_oDelegateType) 
{
    IntPtr l_ProcAddress = GetProcAddress(m_pDLLHandle, a_sProcName);
    if (l_ProcAddress == IntPtr.Zero)
       throw new EntryPointNotFoundException("Function: " …

我正在尝试为 Excel 中的加载项编写一些代码，该加载项从 SQL Server 获取一些数据。代码本身运行完美，但不知何故有些东西被损坏了。

看起来代码可以正常工作几次，然后突然触发 Excel 崩溃。经过很长一段时间，我确定它与引用有关，好像在崩溃时我将引用“Microsoft ActiveX Data Objects 2.8 Library”更改为其他内容，然后再次返回，加载项将工作再次。

鉴于重建加载项不起作用，我开始探索后期绑定的选项。我似乎不明白该怎么做。

Private Sub RetrieveToWorksheet(SQL As String, WriteTo As Range, Optional WriteColumnNames As Boolean = True)

If GetStatus = "True" Then
MsgBox ("Database is currently being updated. Please try again later.")
Exit Sub
End If

Application.ScreenUpdating = False

Dim Connection As ADODB.Connection
Dim RecordSet As ADODB.RecordSet
Dim Field As ADODB.Field
Dim RowOffset As Long
Dim ColumnOffset As Long

     On Error GoTo Finalize
Err.Clear
Set Connection = New …

AFAIK,这是LISP方言的标志性特征:例如,假设我们启动了一个正在进行的LISP程序,该程序重复调用一些名为的函数func.然后我们可以进入lisp REPL,更改定义func,然后在程序下次调用时,程序func的行为将被适当地改变为live.

我相信这个属性被称为后期绑定,虽然我不确定我是否正确.

后期绑定的好处是它允许您在程序仍在运行时重构甚至完全更改程序.这在生物学上类似于这样一个事实,即随着年龄的增长,我们体内的几乎每个细胞都会在足够长的时间范围内被新的细胞取代(当然我们从未注意到).它可以使系统非常灵活.

问题:在Haskell中有什么方法可以做类似的事情吗？如果Haskell不允许这样做,那么它是否有充分的理由(即,是否需要进行更大的权衡才能使其变得有价值)？

的文档Interlocked.Exchange<T>包含以下注释：

此方法重载优于Exchange(Object, Object)方法重载，因为后者需要对目标对象的后期绑定访问。

这张纸条使我很困惑。对我来说，“后期绑定”是指虚拟方法的分派，似乎与原子交换两个内存位置的技术细节没有任何关系。笔记在说什么呢？在这种情况下，“后期访问”是什么意思？