public void CanConvertParameterToConstructorParameter()
{
var rules = new List <ParameterConversionRule>()
{
new ParameterConversionRule(info => info.ParameterType == typeof(int), nfo => new ParameterConversion()
{
ToConstructor = true
})
};
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}), new DelegateToTypeWrapperOptions()
{
ConversionRules = rules
});
Assert.Single(result.GetConstructors());
Assert.Single(result.GetConstructors().Single().GetParameters());
}
public async Task Initialize()
{
var converter = new DelegateToTypeWrapper();
// Convert this catalog's options to the format supported by Delegate Wrapper.
// TODO: At some good point change the catalog so that it uses the Delegate Wrapper's options instead of defining its own.
var delegateToTypeWrapperOptions = ConvertOptions();
var assembly = converter.CreateType(_multicastDelegate, delegateToTypeWrapperOptions);
var options = new TypePluginCatalogOptions()
{
PluginNameOptions = _options.NameOptions
};
if (_options.Tags?.Any() == true)
{
options.TypeFinderOptions = new TypeFinderOptions
{
TypeFinderCriterias = new List <TypeFinderCriteria> {
TypeFinderCriteriaBuilder.Create().Tag(_options.Tags.ToArray())
}
};
}
_catalog = new TypePluginCatalog(assembly, options);
await _catalog.Initialize();
IsInitialized = true;
}
public void CanConvertDelegateToType()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
}
public void GeneratedTypeWorks()
{
var converter = new DelegateToTypeWrapper();
var type = converter.CreateType(new Func <int, bool>(i =>
{
System.Console.WriteLine($"Hello from delegate. I is {i}");
return(true);
}));
dynamic instance = Activator.CreateInstance(type);
var result = instance.Run(25);
}
public void ByDefaultGeneratedTypeName()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
Assert.Equal("GeneratedType", result.Name);
}
public void CanConvertMultipleParametersToConstructorAndPropertyParameters()
{
var rules = new List <ParameterConversionRule>()
{
new ParameterConversionRule(info => info.ParameterType == typeof(int), nfo => new ParameterConversion()
{
ToConstructor = true
}),
new ParameterConversionRule(info => info.ParameterType == typeof(string), nfo => new ParameterConversion()
{
ToPublicProperty = true
}),
new ParameterConversionRule(info => info.ParameterType == typeof(bool), nfo => new ParameterConversion()
{
ToPublicProperty = true
}),
new ParameterConversionRule(info => info.ParameterType == typeof(decimal), nfo => new ParameterConversion()
{
ToConstructor = true
}),
};
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, string, bool, decimal, char, bool>((i, s, arg3, arg4, c) =>
{
_testOutputHelper.WriteLine("Hello from test");
return(true);
}), new DelegateToTypeWrapperOptions()
{
ConversionRules = rules
});
Assert.Single(result.GetConstructors());
Assert.Equal(2, result.GetConstructors().Single().GetParameters().Length);
Assert.Equal(2, result.GetProperties().Length);
dynamic obj = Activator.CreateInstance(result, new object[] { 30, new decimal(22) });
obj.S = "hello";
obj.Arg3 = true;
var res = obj.Run('g');
Assert.True(res);
}
public void ByDefaultNoProperties()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
var type = result;
Assert.Empty(type.GetProperties());
}
public void DelegatesAssemblyContainsVersionInfo()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
var versionInfo = FileVersionInfo.GetVersionInfo(result.Assembly.Location);
var fileVersion = versionInfo.FileVersion;
Assert.NotNull(fileVersion);
}
public void CanConfigureTypenameUsinGenerator()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}), new DelegateToTypeWrapperOptions()
{
TypeNameGenerator = options => "GeneratorTypeName"
});
Assert.Equal("GeneratorTypeName", result.Name);
}
public void CanConfigureNamespace()
{
var converter = new DelegateToTypeWrapper();
var type = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}), new DelegateToTypeWrapperOptions()
{
NamespaceName = "HelloThereNs"
});
Assert.Equal("HelloThereNs", type.Namespace);
}
public void ByDefaultRunMethod()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
var type = result;
var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
Assert.Single(methodInfos);
Assert.Equal("Run", methodInfos.Single().Name);
}
public void ByDefaultNoConstructorParameters()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}));
Assert.Single(result.GetConstructors());
foreach (var constructorInfo in result.GetConstructors())
{
Assert.Empty(constructorInfo.GetParameters());
}
}
public void CanConfigureGeneratedMethodNameUsingGenerator()
{
var converter = new DelegateToTypeWrapper();
var result = converter.CreateType(new Func <int, Task <bool> >(async i =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
_testOutputHelper.WriteLine("Hello from test");
return(true);
}), new DelegateToTypeWrapperOptions()
{
MethodNameGenerator = catalogOptions => "MethodGeneratorName"
});
var method = result.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Single();
Assert.Equal("MethodGeneratorName", method.Name);
}
