Assembly binding at runtim

  • Thread starter Thread starter Abhishek
  • Start date Start date
A

Abhishek

Hi,

I 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
 
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
Click to expand...

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
 
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
Click to expand...

Okay one more input.
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
 
Back
Top