C regards type as generic type T and uses it as generic type of method

The problem is ：

In general , It's impossible to Type Type as generic T To use the , You will receive IDE The tips are as follows

Here, of course, you can directly Person Incoming generics , But I use one Person Class to get the Type Just for testing ,
because In some cases, we only have running Type object , I don't know its specific name .
And use it as a generic type of method

Press IDE A hint of , We can't use it directly like this ,
But Microsoft offers us The reflection method realizes this function

resolvent

Use

 public class Tests
    {
    
        public static string TestMethod<T>()
        {
    
            Console.WriteLine(" The specific incoming type is "+typeof(T));
            return " It's a test ";
        }

        internal class Person
        {
    
            public string Name {
     get; set; }
            public int Id {
     get; set; }
        }
        [Test]
        public void Test1()
        {
    
            
            Type targetType = typeof(Person);
			// Cannot be used directly 
            Tests.TestMethod<targetType>();
            
			// have access to ,MakeGenericMethod You can get multiple one and more generics 
            MethodInfo method = typeof(Tests).GetMethod("TestMethod").MakeGenericMethod(targetType);

            Console.WriteLine(method.Invoke(null, null));
        }


        [SetUp]
        public void Setup()
        {
    
        }

        
        }
   }     

Practical problems to solve ：

I have one ASP.NET CORE Caching tools for ,
stay gitee You can check https://gitee.com/godenSpirit/cache-attribute
It uses SqlSugar Provided Redis Help class to implement the following interface

public interface ICacheable
    {
    
        /// <summary>
        ///  Generic get 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        T Get<T>(string key);

        /// <summary>
        /// object obtain 
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        object Get(string key);
		...........
    }

When using non generic caching methods, you will get another layer of packaging object cache , Cannot return to Swagger
So use generic methods ,
The specific code is as follows ,

//[CacheAble Strategy ] Before the execution of the method , The first strategy is to comment on each line , If you look back, just refer to this 
CacheAble_Strategy_Before = (context, _cache) => {
    
    // Gets the Controller
    ControllerActionDescriptor controller = (ControllerActionDescriptor)context.ActionDescriptor;
    // Further obtain the reflection object of the called interface 
    MethodInfo method = controller.MethodInfo;
    // Get the corresponding strategy from the reflection Attribute,
    CacheAbleAttribute attribute = (CacheAbleAttribute)method.GetCustomAttribute(typeof(CacheAbleAttribute));

    // obtain Attribute Cache name attribute that needs to be resolved in TotalName, analysis ToTalName, Replace to get the real cache name 
    string real_cacheName = CacheNameResolver.ResolveTotalName(attribute.Totoal_Name, context);

    // If the parameter of the annotation is empty, an exception will be reported directly 
    if (string.IsNullOrEmpty(attribute.preffix) || string.IsNullOrEmpty(attribute.Totoal_Name))
        throw new CacheAbleArgsException("The Args Cannot Be NULL");

    // Get the resolved cache name and go to the cache to find whether there is the cache 
    if (_cache.Exist(attribute.preffix + real_cacheName)&&attribute.work==true)
    {
    
		
        //StandResult<object> res = _cache.Get<StandResult<object>>(attribute.preffix + real_cacheName);  The return type of the flag used for the test , You can get 

        // Gets the type of the return value 
        Type returnType = method.ReturnType;
        // Get generics Get Reflection of method （ By returning the value of Type Specify method generics ）
        MethodInfo GetGen = _cache.GetType().GetMethod("Get").MakeGenericMethod(returnType);
        // Radiative call generics Get Method , Get the correct cache information 
        object res = GetGen.Invoke(_cache,new object[] {
    attribute.preffix+real_cacheName});

        return res;
    }
    else
    {
    
        return null; // Go back if you can't find it Null
    }
    
};

For details, please check my CacheAttribute Source code of the tool , Comments are welcome .