Factory.cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2013-2016
// </copyright>
// <summary>   A tested, generic, portable, runtime-extensible type converter library   </summary
// <language>  C# > 6.0                                                                 </language>
// <version>   3.1.0.2                                                                  </version>
// <author>    Lorenz Lo Sauer; people credited in the sources                          </author>
// <project>   https://github.com/lsauer/dotnet-portable-type-cast                      </project>
using System.Reflection;
using System.Linq;
using System;

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace Core.TypeCast.Base
{
    using System.Collections.Generic;
    using Extensions;

    public abstract class Factory<TInstance, TIn1, TIn2> : IFactory<TInstance, TIn1, TIn2> where TInstance : class
    {
        public string Name
        {
            get
            {
                return this.ToString();
            }
        }

        public IEnumerable<Type> GetInterfaces()
        {
            var type = this.GetType();
            yield return type;

            foreach(var interfaceType in type.GetTypeInfo().ImplementedInterfaces)
            {
                yield return interfaceType;
            }
        }

        public IEnumerable<Type> GetParameters()
        {
            var type = this.GetType();
            yield return type;

            foreach(var parameterType in type.GetTypeInfo().GenericTypeParameters)
            {
                yield return parameterType;
            }
        }

        public abstract TInstance Create(TIn1 parameter);

        public abstract TInstance Create(TIn1 parameter, TIn2 parameter2 = default(TIn2));

        protected static object Instantiate(Type type, params object[] parameters)
        {
            return Instantiate<object>(type: type, args: parameters);
        }

        protected static bool TryInstantiate(Type type, out object instance, params object[] parameters)
        {
            instance = null;
            try { 
                instance = Instantiate<object>(type: type, args: parameters);
            } catch(Exception)
            {
                return false;
            }
            return true;
        }

        protected static TOut Instantiate<TOut>(Type type, Type[] parameters, params object[] args)
        {
            var constructed = type.GetTypeInfo().MakeGenericType(parameters);
            var instance = Instantiate<TOut>(type: constructed, args: args);
            return instance;
        }

        protected static TOut Instantiate<TOut>(Type type, object[] args = null)
        {
            if(args?.Length == 0)
            {
                return (TOut)Activator.CreateInstance(type);
            }
            return (TOut)Activator.CreateInstance(type, args);
        }

        public override string ToString()
        {
            var type = this.GetType().GetTypeInfo();
            var genericArgs = type.GenericTypeArguments;
            if(genericArgs.Any())
            {
                var typeNames = genericArgs.Select(t => t.Name)
                    .Aggregate((a, b) => a + ',' + b);
                return $"{type.Name} <{typeNames}>";
            }
            else
            {
                return type.Name;
            }
        }

    }
}