C# dynamic object and case sensitivity of method names and ditto arguments

Question

C# dynamic object and case sensitivity of method names and ditto arguments

EuroEager2008 171

I am using a COM object which often changes the dispatch interface and thus introduce breaking changes.
I have tried switching to using the dynamic keyword and Activator.CreateInstance(Type type) with type from Type.GetTypeFromProgID(string progID).

This seems to work just fine and solves some of the versioning problems of the dispatch interface.
(The object has a fairly simple interface for which lack of intellisense and compile time check doesn't really matter that much, speed is also excellent after the first call (which caches lots of metadata)).

Due to the risk of added arguments to methods of the COM object, I call the methods with named arguments and trust the issuer of the COM object to add arguments with default values.

Then I got a version of the COM object where one method name changed case and similarly one argument name of the method changed case, e.g. Testmethod(string Testargument) changed to TestMethod(string TestArgument).
The calls look like this (myObject is declared as dynamic): var result = myObject.Testmethod(Testargument: "hello") and ditto var result = myObject.TestMethod(TestArgument: "hello").
I then realized that both methodnames and argument (parameter) names are case-insensitive when called by a dynamic object, which obviously fits my case perfectly.

My question is then: Is this case-insensitivity stable by design (and documented? where?) or is there a risk that this may change in the future?

Jack J Jun 25,296

@EuroEager2008 . based on my test, I could not reproduce your problem. In my situation, it will throw the exception If I changed the parameter to upper words.

Here is a code example I am testing.

 internal class Program  
    {  
        static void Main(string[] args)  
        {  
           Type type = typeof(ExampleClass);  
            dynamic d = Activator.CreateInstance(type);  
            d.ExampleMethod2(str:"Hello");  
  
        }  
    }  
  
    class ExampleClass  
    {  
        public ExampleClass() { }  
        public ExampleClass(int v) { }  
  
        public void exampleMethod1(int i) { Console.WriteLine(i); }  
  
        public void exampleMethod2(string str) { Console.WriteLine(str); }  
    }

I only changed Type.GetTypeFromProgID method to typeof(ExampleClass); and they both returns the type.

However, When I run the code, it will get the following error.

EuroEager2008 171 Reputation points

2022-03-17T08:05:22.803+00:00

@Jack J Jun :I am sorry for my mistake, should be a reply on your comment, not a reply to my own question :)

1 answer

Your answer

Jack J Jun 25,296 Reputation points

2022-03-17T06:03:37.277+00:00

@EuroEager2008 . based on my test, I could not reproduce your problem. In my situation, it will throw the exception If I changed the parameter to upper words.

Here is a code example I am testing.

internal class Program { static void Main(string[] args) { Type type = typeof(ExampleClass); dynamic d = Activator.CreateInstance(type); d.ExampleMethod2(str:"Hello"); } } class ExampleClass { public ExampleClass() { } public ExampleClass(int v) { } public void exampleMethod1(int i) { Console.WriteLine(i); } public void exampleMethod2(string str) { Console.WriteLine(str); } }

I only changed Type.GetTypeFromProgID method to typeof(ExampleClass); and they both returns the type.

However, When I run the code, it will get the following error.
EuroEager2008 171 Reputation points

2022-03-17T08:05:22.803+00:00

@Jack J Jun :I am sorry for my mistake, should be a reply on your comment, not a reply to my own question :)

Answer 1

Thanks
This seems to be a bit messy.
I can repro your exception easily, either using .net 5 or .net 6 (probably core 3.1, .net 4.0 (C# 4) etc. as well)

My app was running .Net 6 (with top-level statements which doesn't seem to matter)
Downgrading to .Net Core 3.1 shows same message as yours in a similar case (argument name with "wrong" case)

Using .Net 5 (C# 9 compiler) or .Net 6 (C# 10 compiler) does not show any error in my case.

The principle differences as I can see are:
1: Your program creates the type by typeof(ExampleClass), mine by Type.GetTypeFromProgID("MyProgID")
2: Your program uses a .net class (cls)

Perhaps the fact that you actually introduce the ExampleClass to the compiler makes the difference.
(The compiler has the possibility to add some metadata at compiletime even if dynamic is used, in my case with totally unknown metadata at compile time everything has to be done and cached in runtime)

Based on the observations I have to rephrase my question:
Is this case-insensitivity, using C#9 or C#10 and COM interop by the dynamic keyword stable by design (and documented? where?) or is there a risk that this may change in the future?

EuroEager2008 171 Reputation points

2022-03-17T08:20:47.553+00:00

More observations:
It seems like the error message of my program using .Net core 3.1 is not related to the casing of method names or argumants.
Actually it seems like using dynamic with COM interop is not working at all in .net core 3.1.
The full message is like this, even if casing and all is good:
EuroEager2008 171 Reputation points

2022-03-17T08:28:01.807+00:00

This time I reply my own comment:
dynamic and COM was not supported on .net core until .Net 5, please see https://github.com/dotnet/runtime/issues/12587

Share via

C# dynamic object and case sensitivity of method names and ditto arguments

1 answer

Your answer