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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
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组件，都将被标识，拥有强名。
这需要一次设置就可以了，应该更加方便。
参考文档
Tlbimp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfTypeLibraryImporterTlbimpexe.asp
SN相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfStrongNameUtilitySNexe.asp
Aximp相关：http://msdn.microsoft.com/library/en-us/cptools/html/cpgrfwindowsformsactivexcontrolimporteraximpexe.asp
C#工程的属性说明：http://msdn.microsoft.com/library/en-us/cscon/html/vcurfCProjectGeneralPropertyPage.asp
