阿尔萨斯
- 浏览: 4168557 次
-
最新评论
[收藏]如何用这篇文章解决我们的工程对普通COM组件的引用：《引用ActiveX/COM组件时的Strong Name》
<iframe align="center" marginwidth="0" marginheight="0" src="http://www.zealware.com/csdnblog336280.html" frameborder="0" width="336" scrolling="no" height="280"></iframe>
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
CSharp Tips：引用ActiveX/COM组件时的Strong Name 选择自 Mittermeyer 的 Blog
问题
DotNet平台下提供了比较完备的类库，但是第一个版本总归不可能面面俱到，而且由于历史遗留问题，经常会和COM/ActiveX的组件之间进行互操作。
笔者碰到的问题就是在一个Assembly中调用到了Excel的对象，但是该Assembly需要封装成为一个ActiveX的Control，供IE的客户端脚本调用。简而言之，我在C#中用到了一个COM组件，还需要把自己封装成一个COM组件，听起来有点多余不过想不到更好的办法。
在这样的封装模式下碰到了一个问题，如果一个Assembly希望封装成为ActiveX/COM组件，那么它必须拥有强名（Strong Name），也就是说在编译的时候需要指定SNK（Strong Name Key）。但是当一个Assembly如果以拥有强名的方式编译的话，它又要求所以自身所引用的其他Assembly都必须拥有强名，否则不能够成功编译。而当我们在工程中直接引用一个COM组件（例如：Excel 10 Object Library），VS.Net能够帮助我们自动导入类型库，但是此时的引用类型库是没有强名的，在笔者所期望的环境下无法编译成功。
解决
碰到这个问题觉得很棘手，似乎陷入和死循环，不过查阅一下文档，发现还是非常容易解决的，DotNet Framework中提供了相应的工具能够转换COM的类型库，他就是TlbImp.exe（大家可以在类似“C:/Program Files/Microsoft Visual Studio .NET 2003/SDK/v1.1”的目录中找到）。TlbImp能够将一个COM组件包装成为DotNet可以使用的类库的形式，VS.Net的自动转换想必也是以来这个工具。该工具有很多参数开关，需要支持强名只要额外打开一个开关即可。一下介绍笔者认为最可能用到的参数：
/out:Filename：类型库转换之后输出文件的名称。
/namespace:Namespace：类型库转换所使用的名称空间。
/keyfile:FileName：指定转换时使用的SNK文件，指明该参数，构造之后的类型库就拥有了强名。
完整的例子如下：
tlbimp excel.exe /out:interop.excel.dll /namespace:Excel /keyfile:excel.snk
其中snk文件可以通过DotNet中的另一个工具SN生成，此处不再赘述。
完成上述工作，在工程中直接引用我们自己构造的类型库，就可以成功的编译拥有强名的DLL了。
如果是控件，而不是普通的Component，那么就不能够使用tlbimp，而需要使用aximp.exe这个工具，使用方法与tlbimp类似，他会生成两个文件：一个是类型库的代理文件，另一个是Windows Form的代理文件。
进一步解决
然而还有更加简单的解决办法，就是在工程属性中设置“Wrapper Assembly Key File”（Common Properties/General/Wrapper Assembly Key File），这个属性。设置了该属性之后通过Add Reference添加的COM/ActiveX组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
分享到：
发表评论
相关推荐
说明：需要安装ActiveX插件 地址： http://cn.mcafee.com/root/mfs/default.asp?cid=16943 趋势科技在线扫毒 说明：需要安装ActiveX插件 地址： http://www.trendmicro.com.cn/housecall/start_corp.asp 光华...
无效Activex与COM组件清理器，要清理没有用的Activex控件可以用这个软件
Studio for ActiveX 1/2含注册机 Componentone Studio 2009 v3 Full OS: Win32 | 483 MB Componentone Studio 2009 v3 Full Studio for Mobile http://download.csdn.net/source/1926145 Componentone Studio 2009 ...
Studio for ActiveX 含注册机 2/2 Componentone Studio 2009 v3 Full OS: Win32 | 483 MB Componentone Studio 2009 v3 Full Studio for Mobile http://download.csdn.net/source/1926145 Componentone Studio 2009...
基于C++ ActiveX/com 的绘图组件 V2.1 相关的DLL，组件V2.0 无法使用
是第一个国产ActiveX商业组件； Cell组件适用于Windows环境下各种开发工具(如VB， VC，Visual Foxpro, Delphi, C++ Builder, PowerBuilder等,Cell插件用于开发B/S结构程序，使用语 言VBScript，JavaScript等。Cell...
procedure CreateShortCut(FileName, ShortCutName: String); //在桌面上创建快捷方式 //Example CreateShortCut('c:\windows\notepad.exe','记事本') //use Shellapi, ActiveX, ComObj, Shlobj function AddTail...
ASP与ActiveX服务器组件应用技巧：共分七章,第一章：创建一个简单的ASP页;第二章：创建HTML表格;第三章：使用Ad Rotator(广告轮换器)组件;第四章：使用Browser Capabilities(浏览器性能)组件;第五章:使用Database ...
可对com组件进行调试64位的COM组件，工具方便简单，可对写的方法进行测试。
在ActiveX控件中引入窗体技术
ActiveX组件与JavaScript交互ActiveX组件与JavaScript交互ActiveX组件与JavaScript交互
Componentone Studio 2009 v3 Full Studio for ActiveX 2/2 http://download.csdn.net/source/1927638 http://download.csdn.net/source/1927644 Componentone Studio 2009 v3 Full Studio for WPF 1/2 ...
使用糖果专业下载组件，可以使你的软件在网络数据获取方面达到专业水准，而无需了解复杂的网络底层和网络协议。 糖果专业下载组件在以下方面有突出优势： 1 极快的下载速度，在同等网络条件下（相同目标文件，相同...
个人对COM组件和ActiveX开发的一些总结
让ActiveX在FireFox和Chrome等NPAPI插件接口的浏览器中上运行 这样firefox浏览器就可以正常浏览有ActiveX插件的网页，比如flash 的ActiveX控件： id="Control" TYPE="application/x-itst-activex" WIDTH="300" ...
Componentone Studio 2009 v3 Full Studio for ActiveX 2/2 http://download.csdn.net/source/1927638 http://download.csdn.net/source/1927644 Componentone Studio 2009 v3 Full Studio for WPF 1/2 ...
基于C++ 开发的ActiveX 控件，无任何限制，随便使用，随便分发
SkinCrafter v3.4.0 ActiveX/DLL/DotNet破解补丁
压缩包中一个pdf说明文档，讲述如何创建activeX 两个VC6.0工程文件，一个生成activeX 一个测试activeX控件
最后举了两个例子说明了如何使用这个刚刚生产得控件.一个是把该控件应用到网页中,一个则是用于一个基于对话框的程序中.详细代码请下载压缩包. (一) 创建工程 (1) 打开VC6集成开发环境，按新建按钮，选择PROJECT...