|
dev
newsgroups
|
|||||||||||||||||||||||
|
|||||||||||||||||||||||
Assembly binding at runtimI am using .NET framework 2.0 and am facing a problem with assembly versioning. We have a many dlls which we ship as an application. Now all these dlls are packaged and shipped as independent units. These dlls may or may not depend on each other however 1 thing which is for sure is that all the dlls depend on a common dll. So to make it more clear the scenario is i have dll1, dll2, dllCommon. Now dll1 and dll2 depends on dllCommon. The AssemlblyVersionInfo we have set for all these dlls is 1.5.*.* . Now with each build we build dllCommmon, dll2 and dll1 in the same order. Once we ship the application we may have to patch any 1 of these dlls individually. However when we try to do that the things break because of the way runtime probes the signed dlls. (We've all of them signed by a key). So the problem now is that even if i have to patch dllCommon i have to ship dll1 and dll2 as well which is definitely not possible for us. I am sure there's a solution out there however i am not able to find it. Any comments/help would be great inputs for me. Thanks, Abhishek Hello, Abhishek!
IMO the purpose of assembly signing is to remove the possibility to modify the app by other people. Since your application consists of many dlls - removing one dll means that other dlls have to be rebuild and signed again. A solutions can be an installer application that will do the patch thus substitute all the dlls. Also an application has to be installed by the installer. Another way is not to signe application dlls (not applicable). -- With best regards, Vadym Stetsiak. Blog: http://vadmyst.blogspot.com You wrote on Wed, 17 Oct 2007 00:21:51 -0700: A> Hi, A> I am using .NET framework 2.0 and am facing a problem with assembly A> versioning. A> We have a many dlls which we ship as an application. Now all these A> dlls are packaged and shipped as independent units. These dlls may or A> may not depend on each other however 1 thing which is for sure is A> that all the dlls depend on a common dll. A> So to make it more clear the scenario is i have dll1, dll2, A> dllCommon. A> Now dll1 and dll2 depends on dllCommon. The AssemlblyVersionInfo we A> have set for all these dlls is 1.5.*.* . Now with each build we build A> dllCommmon, dll2 and dll1 in the same order. A> Once we ship the application we may have to patch any 1 of these dlls A> individually. However when we try to do that the things break because A> of the way runtime probes the signed dlls. (We've all of them signed A> by a key). So the problem now is that even if i have to patch A> dllCommon i have to ship dll1 and dll2 as well which is definitely A> not possible for us. A> I am sure there's a solution out there however i am not able to find A> it. Any comments/help would be great inputs for me. A> Thanks, Abhishek
Show quote
On Oct 17, 12:47 pm, "Vadym Stetsiak" <vadm***@gmail.com> wrote: Hi Vadyam> Hello, Abhishek! > > IMO the purpose of assembly signing is to remove the possibility to modify > the app by other people. > Since your application consists of many dlls - removing one dll means that > other dlls have to be rebuild and signed again. > > A solutions can be an installer application that will do the patch thus > substitute all the dlls. Also an application has to be installed by the > installer. > Another way is not to signe application dlls (not applicable). > -- > With best regards, Vadym Stetsiak. > Blog:http://vadmyst.blogspot.com > > You wrote on Wed, 17 Oct 2007 00:21:51 -0700: > > A> Hi, > > A> I am using .NET framework 2.0 and am facing a problem with assembly > A> versioning. > > A> We have a many dlls which we ship as an application. Now all these > A> dlls are packaged and shipped as independent units. These dlls may or > A> may not depend on each other however 1 thing which is for sure is > A> that all the dlls depend on a common dll. > > A> So to make it more clear the scenario is i have dll1, dll2, > A> dllCommon. > A> Now dll1 and dll2 depends on dllCommon. The AssemlblyVersionInfo we > A> have set for all these dlls is 1.5.*.* . Now with each build we build > A> dllCommmon, dll2 and dll1 in the same order. > A> Once we ship the application we may have to patch any 1 of these dlls > A> individually. However when we try to do that the things break because > A> of the way runtime probes the signed dlls. (We've all of them signed > A> by a key). So the problem now is that even if i have to patch > A> dllCommon i have to ship dll1 and dll2 as well which is definitely > A> not possible for us. > A> I am sure there's a solution out there however i am not able to find > A> it. Any comments/help would be great inputs for me. > > A> Thanks, Abhishek Definitely this is doable if i ship all the dlls however the issue here is that all these dlls would be built by different team and a subset would then shipped to customers depending on there requirements. Now we can't write a installer for each customer. Additionaly it is logically incorrect to ship all the dlls if i have to patch only dll1. Any other ideas ? ~Abhishek On Oct 17, 1:25 pm, Abhishek <luckyabhis***@gmail.com> wrote:
Show quote > On Oct 17, 12:47 pm, "Vadym Stetsiak" <vadm***@gmail.com> wrote: Okay one more input.> > > > > Hello, Abhishek! > > > IMO the purpose of assembly signing is to remove the possibility to modify > > the app by other people. > > Since your application consists of many dlls - removing one dll means that > > other dlls have to be rebuild and signed again. > > > A solutions can be an installer application that will do the patch thus > > substitute all the dlls. Also an application has to be installed by the > > installer. > > Another way is not to signe application dlls (not applicable). > > -- > > With best regards, Vadym Stetsiak. > > Blog:http://vadmyst.blogspot.com > > > You wrote on Wed, 17 Oct 2007 00:21:51 -0700: > > > A> Hi, > > > A> I am using .NET framework 2.0 and am facing a problem with assembly > > A> versioning. > > > A> We have a many dlls which we ship as an application. Now all these > > A> dlls are packaged and shipped as independent units. These dlls may or > > A> may not depend on each other however 1 thing which is for sure is > > A> that all the dlls depend on a common dll. > > > A> So to make it more clear the scenario is i have dll1, dll2, > > A> dllCommon. > > A> Now dll1 and dll2 depends on dllCommon. The AssemlblyVersionInfo we > > A> have set for all these dlls is 1.5.*.* . Now with each build we build > > A> dllCommmon, dll2 and dll1 in the same order. > > A> Once we ship the application we may have to patch any 1 of these dlls > > A> individually. However when we try to do that the things break because > > A> of the way runtime probes the signed dlls. (We've all of them signed > > A> by a key). So the problem now is that even if i have to patch > > A> dllCommon i have to ship dll1 and dll2 as well which is definitely > > A> not possible for us. > > A> I am sure there's a solution out there however i am not able to find > > A> it. Any comments/help would be great inputs for me. > > > A> Thanks, Abhishek > > Hi Vadyam > > Definitely this is doable if i ship all the dlls however the issue > here is that all these dlls would be built by different team and a > subset would then shipped to customers depending on there > requirements. > Now we can't write a installer for each customer. Additionaly it is > logically incorrect to ship all the dlls if i have to patch only > dll1. > > Any other ideas ? > > ~Abhishek I read somewhere that binding policies might help here however i am not sure how can i say in the binding policies that bind to any version higher then what the assembly has been compiled against. I couldn't find any example/ documentation on msdn for writing such a policy. ~Abhishek |
|||||||||||||||||||||||