"Born Bugler" <wondertop@263.net> wrote in message
news:eui17o$6dc$1@news.yaako.com...
> What I'm actually talking about is, when you put the same class in
> different assemblies, you get two different types. This is reasonable (if
> you would call it) in most cases as it avoids possible misuse. However,
> what about if I do want to consider classes with exactly the same
> definition in different assemblies to be the same? I tried interpret_cast,
> but it works only for trivial scenarios like below:
>
> ref class ClassA
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
> };
>
> ref class ClassB
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
> };
>
> int main()
> {
> ClassA^ ca = gcnew ClassA();
> ClassB^ cb = reinterpret_cast<ClassB^>(ca);
> cb->DoSomething(); // OK, output "From ClassA"
> }
>
> However, if you make the scenario more complex by adding some base classes
> to ClassA and ClassB, reinterpret_cast fails, as shown below:
>
> interface class InfA
> {
> DoSomething();
> };
> interface class InfB
> {
> DoSomething();
> };
>
> ref class ClassA : public InfA
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
> };
>
> ref class ClassB : public InfB
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
> };
>
> int main()
> {
> InfA^ ca = gcnew ClassA();
> InfB^ cb = reinterpret_cast<InfB^>(ca);
> cb->DoSomething(); // Oh, an exception "Entry point not found" is
> thrown here.
> }
>
> In standard C++, I don't think there will be any problem with the above
> attempt. However, in C++/CLI, well, I'm waiting for your reply...
>
> Born
>

"Kevin Frey" <kevin_g_frey@hotmail.com> wrote in message
:OmX43pocHHA.1000@TK2MSFTNGP05.phx.gbl...
> Native C++ has no such problem because the types do not have a "strong
> name". Types in managed assemblies, on the other hand, have a "strong
> name" which means that type X in one assembly is not the same as type X in
> another assembly, because their strong names are different.
>
> You mention different assemblies. Are the two assemblies somehow related
> or completely unrelated?
>
> If they are completely unrelated then you might want to factor out the
> shared types into a third assembly and have both of the other assemblies
> depend on types defined within it. That way they are both using the same
> strong name, hence referring to the same type.
>
> If they are related then one of the assemblies should control the class
> definition and the other assembly should use it. That way they are both
> using the same type definition.
>
> Kevin.
>
>
> "Born Bugler" <wondertop@263.net> wrote in message
> news:eui17o$6dc$1@news.yaako.com...
>> What I'm actually talking about is, when you put the same class in
>> different assemblies, you get two different types. This is reasonable (if
>> you would call it) in most cases as it avoids possible misuse. However,
>> what about if I do want to consider classes with exactly the same
>> definition in different assemblies to be the same? I tried
>> interpret_cast, but it works only for trivial scenarios like below:
>>
>> ref class ClassA
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
>> };
>>
>> ref class ClassB
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
>> };
>>
>> int main()
>> {
>> ClassA^ ca = gcnew ClassA();
>> ClassB^ cb = reinterpret_cast<ClassB^>(ca);
>> cb->DoSomething(); // OK, output "From ClassA"
>> }
>>
>> However, if you make the scenario more complex by adding some base
>> classes to ClassA and ClassB, reinterpret_cast fails, as shown below:
>>
>> interface class InfA
>> {
>> DoSomething();
>> };
>> interface class InfB
>> {
>> DoSomething();
>> };
>>
>> ref class ClassA : public InfA
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
>> };
>>
>> ref class ClassB : public InfB
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
>> };
>>
>> int main()
>> {
>> InfA^ ca = gcnew ClassA();
>> InfB^ cb = reinterpret_cast<InfB^>(ca);
>> cb->DoSomething(); // Oh, an exception "Entry point not found" is
>> thrown here.
>> }
>>
>> In standard C++, I don't think there will be any problem with the above
>> attempt. However, in C++/CLI, well, I'm waiting for your reply...
>>
>> Born
>>
>
>

> ref class ClassA
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
> };
>
> ref class ClassB
> {
> public:
> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
> };
>
> int main()
> {
> ClassA^ ca = gcnew ClassA();
> ClassB^ cb = reinterpret_cast<ClassB^>(ca);
> cb->DoSomething(); // OK, output "From ClassA"
> }

> Hi Born!
>
>> ref class ClassA
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassA" ); }
>> };
>>
>> ref class ClassB
>> {
>> public:
>> virtual DoSomething(){ Console::WriteLine( "From ClassB" ); }
>> };
>>
>> int main()
>> {
>> ClassA^ ca = gcnew ClassA();
>> ClassB^ cb = reinterpret_cast<ClassB^>(ca);
>> cb->DoSomething(); // OK, output "From ClassA"
>> }
>
> You should use "Reflection" to call the "DoSomething" method!
>
> Greetings
> Jochen

> Oh, no, Jochen.
>
> Please give me a detailed solution. Personally, I would say it will be much
> harder than you have thought.

> Hi Born!
>> Oh, no, Jochen.
>>
>> Please give me a detailed solution. Personally, I would say it will be
>> much harder than you have thought.
>
>
> Regardless, that the "correct solution" is to put the "common" class in a
> common-assembly, you can use refelction:
>
> namespace Foo
> {
> ref class A
> {
> public: void DoSomething() {
> System::Console::WriteLine("A::DoSomething"); }
> };
>
> ref class B
> {
> public: void DoSomething() {
> System::Console::WriteLine("B::DoSomething"); }
> };
>
> ref class General
> {
> public: void static DoSomething(Object ^instance)
> {
> if (instance == nullptr) throw gcnew
> System::NullReferenceException("'instance' must be set!");
> System::Type ^t = instance->GetType();
> System::Reflection::MethodInfo ^mi = t->GetMethod("DoSomething",
> gcnew array<System::Type^> {});
> if (mi == nullptr) throw gcnew System::MethodAccessException("Method
> 'DoSomething' not found!");
> mi->Invoke(instance, gcnew array<Object^> {});
> }
> };
> }
>
> int main()
> {
> Foo::A ^a = gcnew Foo::A();
> Foo::B ^b = gcnew Foo::B();
>
> Foo::General::DoSomething(a);
> Foo::General::DoSomething(b);
> }
>
> Greetings
> Jochen

> So you misunderstood me.

Born Bugler wrote:

> They are unrelated. I know exactly your solution. But what if I don't want a
> third assembly?

> In many cases the third assembly would be filled with only
> interfaces, and it looks silly to maintain a separate assembly for that
> purpose.