public static HResult CreateInstance(this INiLocalRegistry self, Guid guid, IServiceProvider serviceProvider, out object instance)
{
instance = null;
try
{
var hr = self.CreateInstance(guid, out instance);
if (ErrorUtil.Failure(hr))
return hr;
if (serviceProvider != null)
{
var objectWithSite = instance as INiObjectWithSite;
if (objectWithSite != null)
{
hr = objectWithSite.SetSite(serviceProvider);
if (ErrorUtil.Failure(hr))
return hr;
}
}
return HResult.OK;
}
catch (Exception ex)
{
return ErrorUtil.GetHResult(ex);
}
}
internal static object CreateInstance(this Type type, int arrayLength)
{
if (type == null)
return null;
return type.CreateInstance(arrayLength, string.Format("Type '{0}' must expose a public parameterless constructor.", type.Name));
}
public static object CreateInstance(this Type type, List<object> constructorArguments)
{
if (type == null) throw new ArgumentNullException("type");
if (constructorArguments == null) throw new ArgumentNullException("constructorArguments");
return type.CreateInstance(constructorArguments.ToArray());
}
/// <include file='../_Doc/mscorlib.xml' path='doc/members/member[@name="M:System.Reflection.Assembly.CreateInstance(System.String)"]/*' />
/// <param name="assembly">Assembly on which the <paramref name="typeName"/> instance should be created.</param>
public static object CreateInstance(this Assembly assembly, string typeName)
{
#if DOTNET || WINDOWS_PHONE || WINDOWS_PHONE_APP
return assembly.CreateInstance(typeName);
#else
throw new PlatformNotSupportedException("PCL");
#endif
}
/// <summary>
/// Creates an object instance.
/// </summary>
/// <param name="factory">The target factory.</param>
/// <param name="serviceType">The requested service type.</param>
/// <param name="container">The target service contaienr.</param>
/// <param name="additionalArguments">The additional arguments that will be used to create the service instance.</param>
/// <returns>A service instance.</returns>
public static object CreateInstance(this IFactory factory, Type serviceType,
IServiceContainer container, params object[] additionalArguments)
{
var request = new FactoryRequest()
{
ServiceName = null,
ServiceType = serviceType,
Arguments = additionalArguments
};
return factory.CreateInstance(request);
}
public static Object Reify(this Type t)
{
if (t.SameMetadataToken(typeof(IEnumerable<>)) ||
t.SameMetadataToken(typeof(ICollection<>)) ||
t.SameMetadataToken(typeof(IList<>)))
{
var t_el = t.XGetGenericArguments().AssertSingle();
t = typeof(List<>).XMakeGenericType(t_el);
}
if (t.SameMetadataToken(typeof(IDictionary<,>)))
{
var t_key = t.XGetGenericArguments().First();
if (t_key == typeof(String))
{
var t_value = t.XGetGenericArguments().Second();
t = typeof(Dictionary<,>).XMakeGenericType(t_key, t_value);
}
}
if (t.IsInterface || t.IsAbstract)
{
var key = typeof(Demiurge).Assembly.ReadKey("XenoGears.XenoGears.snk");
var unit = Codegen.Units["XenoGears.Demiurge", key];
t = unit.Context.GetOrCreate(t, () =>
{
var name = String.Format("Reified_{0}", t.Name);
var rt = unit.Module.DefineType(name, TA.Public);
if (t.IsInterface) t.Hierarchy().ForEach(rt.AddInterfaceImplementation);
else rt.SetParent(t);
var abstracts = t.Hierarchy().SelectMany(ht => ht.GetProperties(BF.AllInstance)).Where(p => p.IsAbstract()).ToReadOnly();
abstracts = abstracts.Where(p1 => abstracts.None(p2 => p2.Overrides(p1))).ToReadOnly();
abstracts.ForEach(p =>
{
MethodBuilder get, set;
rt.DefineOverride(p, out get, out set);
var f = rt.DefineField("_" + p.Name.Uncapitalize(), p.PropertyType, FA.Private);
if (get != null) get.il().ldarg(0).ldfld(f).ret();
if (set != null) set.il().ldarg(0).ldarg(1).stfld(f).ret();
});
return rt.CreateType();
}).AssertCast<Type>();
}
var cfg = t.Config().DefaultEngine().Config;
var default_ctor = cfg.DefaultCtor && t.HasDefaultCtor();
return default_ctor ? t.CreateInstance() : t.CreateUninitialized();
}
/// <summary>
/// Creates an instance with the provided arguments (if any).
/// </summary>
/// <param name="typeInfo">The type information.</param>
/// <param name="args">The arguments.</param>
/// <returns>
/// The new instance.
/// </returns>
public static object CreateInstance(this IRuntimeTypeInfo typeInfo, params object[] args)
{
Contract.Requires(typeInfo != null);
return typeInfo.CreateInstance((IEnumerable<object>)args);
}
internal static object CreateInstance(this Type type)
{
return type.CreateInstance(0);
}
internal static object CreateInstance(this PropertyInfo property)
{
return property.CreateInstance(0);
}
public static object GetDefaultValue(this Type type) {
return type.IsValueType ? type.CreateInstance() : null;
}
public static object CreateInstanceWithInitializerKeywords(this Type type, List<object> constructorArguments)
{
if (type == null) throw new ArgumentNullException("type");
if (constructorArguments == null) throw new ArgumentNullException("constructorArguments");
var constructorArgs = new List<object>();
// Everything up to the first keyword is a constructor arg
int i;
for (i = 0; i < constructorArguments.Count; i++)
{
var s = constructorArguments[i] as Symbol;
if (s != null && s.IsKeyword)
break;
constructorArgs.Add(constructorArguments[i]);
}
if (((constructorArguments.Count - i) & 1) != 0)
throw new ArgumentException("Odd number of initializer arguments provided");
object o = type.CreateInstance(constructorArgs);
for (; i + 1 < constructorArguments.Count; i += 2)
{
var name = constructorArguments[i] as Symbol;
if (name == null)
throw new ArgumentException("Improper initializer name: " + constructorArguments[i]);
o.SetPropertyOrField(name.KeywordName, constructorArguments[i + 1]);
}
return o;
}
public static object CreateInstance(this Type type, params object[] args)
{
return type.CreateInstance(BindingFlags.Public, args);
}
/// <summary>
/// Gets an SQL Local DB instance with the specified name if it exists, otherwise a new instance with the specified name is created.
/// </summary>
/// <param name="value">The <see cref="ISqlLocalDbProvider"/> to use to get or create the instance.</param>
/// <param name="instanceName">The name of the SQL Server LocalDB instance to get or create.</param>
/// <returns>
/// An SQL Local DB instance with the name specified by <paramref name="instanceName"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="value"/> or <paramref name="instanceName"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="InvalidOperationException">
/// <paramref name="value"/> returns <see langword="null"/> when queried for instances.
/// </exception>
public static ISqlLocalDbInstance GetOrCreateInstance(this ISqlLocalDbProvider value, string instanceName)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (instanceName == null)
{
throw new ArgumentNullException("instanceName");
}
bool instanceExists = false;
if (SqlLocalDbApi.IsDefaultInstanceName(instanceName))
{
// The default instance is always listed, even if it does not exist,
// so need to query that separately to verify whether to get or create.
instanceExists = SqlLocalDbApi.GetInstanceInfo(instanceName).Exists;
}
else
{
// This approach is used otherwise for testability
IList<ISqlLocalDbInstanceInfo> instances = value.GetInstances();
if (instances != null)
{
// Instance names in SQL Local DB are case-insensitive
instanceExists = instances
.Where((p) => p != null)
.Where((p) => string.Equals(p.Name, instanceName, StringComparison.OrdinalIgnoreCase))
.Any();
}
}
if (instanceExists)
{
return value.GetInstance(instanceName);
}
else
{
return value.CreateInstance(instanceName);
}
}
