Add more dynamic feature to make reflection more easily

[wherewhere]

For example, if we need to start a process by reflection, we need to write a long code like this.

Assembly system = Assembly.Load(new AssemblyName("System"));

dynamic psi = Activator.CreateInstance(system.GetType("System.Diagnostics.ProcessStartInfo"), filename, command);
psi.CreateNoWindow = true;
psi.WindowStyle = (dynamic)Enum.Parse(system.GetType("System.Diagnostics.ProcessWindowStyle"), "Hidden");
psi.UseShellExecute = false;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;

dynamic process = system.GetType("System.Diagnostics.Process")
                        .GetMethods()
                        .Where(x => x.IsStatic && x.IsPublic && x.Name == "Start" && x.GetParameters() is ParameterInfo[] array && array.Length == 1 && array[0].ParameterType.Name == "ProcessStartInfo")
                        .First()
                        .Invoke(null, [psi]);

We need write a lot to create an instance and invoke a static method. So shall we simplify it like:

dynamic psi = new typeof["System.Diagnostics.ProcessStartInfo"](filename, command);
psi.CreateNoWindow = true;
psi.WindowStyle = dynamic typeof["System.Diagnostics.ProcessWindowStyle"].Hidden;
psi.UseShellExecute = false;
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;

dynamic process = dynamic typeof["System.Diagnostics.Process"].Start(psi);

typeof[string], like typeof(T), can get a type by the name of type. the [] meens it like an index to index a type from all the types. For example:

{
    Type type = typeof["System.String"]; // Get a type of `System.String`
}
{
    Assembly system = Assembly.Load(new AssemblyName("System"));
    Type type = typeof["System.String"] from system; // Get the `System.String` type from assembly `System`
}

Then we can add more feature of Type. For example:

// `new Type`, to create an instance direct from a type
Type strType = typeof["System.String"];
dynamic str = new strType("Hello World!".ToCharArray());

// `dynamic Type`, to get a enum or static member from a type
Type comparisonType = typeof["System.StringComparison"];
dynamic result = dynamic strType.Equals(str, "HELLO WORLD!", dynamic comparisonType.OrdinalIgnoreCase);

We can also have default[Type] to get the default instance of target type, nameof[Type] to get the name of target type and sizeof[Type] to get the size of target type.

[huoyaoyuan]

I don't think dynamic feature is encouraged or actively developed.

What is the real scenario to use reflection when the exact steps to call are already known? Accessing excessive internal code?

[wherewhere]

I use that process example is because .NET Core 5.0 (.NET for UWP) is not support Process. But it is running on .NET Framework when it build as console. So I need to reflect Process to use it.
It also need to use reflect when you load assembly from file. It need an easy way to create instance from a type.

[huoyaoyuan]

.NET Core 5.0 (.NET for UWP)

netcore50 is not .NET Core 5.0. UWP uses a fork of .NET Core 2.x.

It also need to use reflect when you load assembly from file.

If the types in the console application is public, you can reference it as a library.
Note that .NET for UWP has very limited capability comparing to .NET Framework. Loading a command line application may not work in process.
Do you need to create more types other than invoking its Main? Is reflection so excessive to worth dedicated syntax?