diff --git a/Conari/Conari.csproj b/Conari/Conari.csproj
index dc25757..7332676 100644
--- a/Conari/Conari.csproj
+++ b/Conari/Conari.csproj
@@ -87,6 +87,7 @@
     <Compile Include="Types\Action\Ref\ActionRef.cs" />
     <Compile Include="Types\Action\Out\ActionOut.cs" />
     <Compile Include="Types\BSTR.cs" />
+    <Compile Include="Types\Methods\Method.cs" />
     <Compile Include="Types\IBoxed.cs" />
     <Compile Include="Types\INullType.cs" />
     <Compile Include="Types\NullType.cs" />
diff --git a/Conari/Core/IBinder.cs b/Conari/Core/IBinder.cs
index 5343fc5..afb4809 100644
--- a/Conari/Core/IBinder.cs
+++ b/Conari/Core/IBinder.cs
@@ -22,11 +22,15 @@
  * THE SOFTWARE.
 */
 
+using System;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using net.r_eg.Conari.Types.Methods;
 
 namespace net.r_eg.Conari.Core
 {
+    using Method = Method<object, object>;
+
     public interface IBinder
     {
         /// <summary>
@@ -37,6 +41,14 @@ public interface IBinder
         /// <returns>Delegate of exported function.</returns>
         T bindFunc<T>(string lpProcName) where T : class;
 
+        /// <summary>
+        /// Alias `bindFunc&lt;Action&gt;(string lpProcName)`
+        /// Binds the exported function.
+        /// </summary>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Action bindFunc(string lpProcName);
+
         /// <summary>
         /// Binds the exported C API Function.
         /// </summary>
@@ -46,16 +58,24 @@ public interface IBinder
         T bind<T>(string func) where T : class;
 
         /// <summary>
-        /// Binds the exported Function via MethodInfo.
+        /// Alias `bind&lt;Action&gt;(string func)`
+        /// Binds the exported C API Function.
         /// </summary>
-        /// <param name="mi">Prepared signature with valid function name.</param>
-        /// <param name="prefix">Add prefix to function name from IProvider.Prefix if true.</param>
-        /// <returns>
-        ///     Complete information to: 
-        ///     * create delegates ~ `dyn.CreateDelegate(type.declaringType) as T`
-        ///     * or to invoke methods ~ `dyn.Invoke(null, mParams)`
-        /// </returns>
-        TDyn bind(MethodInfo mi, bool prefix = false);
+        /// <param name="func">The name of exported C API function.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Action bind(string func);
+
+        ///// <summary>
+        ///// Binds the exported Function via MethodInfo.
+        ///// </summary>
+        ///// <param name="mi">Prepared signature with valid function name.</param>
+        ///// <param name="prefix">Add prefix to function name from IProvider.Prefix if true.</param>
+        ///// <returns>
+        /////     Complete information to: 
+        /////     * create delegates ~ `dyn.CreateDelegate(type.declaringType) as T`
+        /////     * or to invoke methods ~ `dyn.Invoke(null, mParams)`
+        ///// </returns>
+        //TDyn bind(MethodInfo mi, bool prefix = false);
 
         /// <summary>
         /// Binds the exported Function via MethodInfo and an specific name.
@@ -78,5 +98,45 @@ public interface IBinder
         /// <param name="conv">How it should be called. It overrides only for current method.</param>
         /// <returns>Complete information to create delegates or to invoke methods.</returns>
         TDyn bind(MethodInfo mi, string name, CallingConvention conv);
+
+        /// <summary>
+        /// Alias `bindFunc&lt;object&gt;(string lpProcName, Type ret, params Type[] args)`
+        /// Binds the exported function.
+        /// </summary>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Method bindFunc(string lpProcName, Type ret, params Type[] args);
+
+        /// <summary>
+        /// Binds the exported function.
+        /// </summary>
+        /// <typeparam name="T">The return type for new Delegate should be as T type.</typeparam>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Method<T, object> bindFunc<T>(string lpProcName, Type ret, params Type[] args);
+
+        /// <summary>
+        /// Alias `bind&lt;object&gt;(string func, Type ret, params Type[] args)`
+        /// Binds the exported C API Function.
+        /// </summary>
+        /// <param name="func">The name of exported C API function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Method bind(string func, Type ret, params Type[] args);
+
+        /// <summary>
+        /// Binds the exported C API Function.
+        /// </summary>
+        /// <typeparam name="T">The return type for new Delegate should be as T type.</typeparam>
+        /// <param name="func">The name of exported C API function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        Method<T, object> bind<T>(string func, Type ret, params Type[] args);
     }
 }
diff --git a/Conari/Core/Provider.cs b/Conari/Core/Provider.cs
index d1550fa..61324df 100644
--- a/Conari/Core/Provider.cs
+++ b/Conari/Core/Provider.cs
@@ -31,11 +31,13 @@
 using net.r_eg.Conari.Exceptions;
 using net.r_eg.Conari.Log;
 using net.r_eg.Conari.Types;
+using net.r_eg.Conari.Types.Methods;
 using net.r_eg.Conari.WinAPI;
 
 namespace net.r_eg.Conari.Core
 {
     using CMangling = Mangling.C;
+    using Method = Method<object, object>;
 
     public abstract class Provider: Loader, ILoader, IProvider
     {
@@ -104,6 +106,17 @@ public T bindFunc<T>(string lpProcName) where T : class
             return getDelegate<T>(lpProcName);
         }
 
+        /// <summary>
+        /// Alias `bindFunc&lt;Action&gt;(string lpProcName)`
+        /// Binds the exported function.
+        /// </summary>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Action bindFunc(string lpProcName)
+        {
+            return bindFunc<Action>(lpProcName);
+        }
+
         /// <summary>
         /// Binds the exported C API Function.
         /// </summary>
@@ -116,17 +129,28 @@ public T bind<T>(string func) where T : class
         }
 
         /// <summary>
-        /// Binds the exported Function via MethodInfo.
+        /// Alias `bind&lt;Action&gt;(string func)`
+        /// Binds the exported C API Function.
         /// </summary>
-        /// <param name="mi">Prepared signature.</param>
-        /// <param name="prefix">Add prefix to function name from IProvider.Prefix if true.</param>
-        /// <returns>Complete information to create delegates or to invoke methods.</returns>
-        public TDyn bind(MethodInfo mi, bool prefix = false)
+        /// <param name="func">The name of exported C API function.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Action bind(string func)
         {
-            string func = prefix ? funcName(mi.Name) : mi.Name;
-            return wire(mi, func);
+            return bind<Action>(func);
         }
 
+        ///// <summary>
+        ///// Binds the exported Function via MethodInfo.
+        ///// </summary>
+        ///// <param name="mi">Prepared signature.</param>
+        ///// <param name="prefix">Add prefix to function name from IProvider.Prefix if true.</param>
+        ///// <returns>Complete information to create delegates or to invoke methods.</returns>
+        //public TDyn bind(MethodInfo mi, bool prefix = false)
+        //{
+        //    string func = prefix ? funcName(mi.Name) : mi.Name;
+        //    return wire(mi, func);
+        //}
+
         /// <summary>
         /// Binds the exported Function via MethodInfo and an specific name.
         /// </summary>
@@ -150,6 +174,63 @@ public TDyn bind(MethodInfo mi, string name, CallingConvention conv)
             return wire(mi, name, conv);
         }
 
+        /// <summary>
+        /// Alias `bindFunc&lt;object&gt;(string lpProcName, Type ret, params Type[] args)`
+        /// Binds the exported function.
+        /// </summary>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Method bindFunc(string lpProcName, Type ret, params Type[] args)
+        {
+            return bindFunc<object>(lpProcName, ret, args);
+        }
+
+        /// <summary>
+        /// Binds the exported function.
+        /// </summary>
+        /// <typeparam name="T">The return type for new Delegate should be as T type.</typeparam>
+        /// <param name="lpProcName">The full name of exported function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Method<T, object> bindFunc<T>(string lpProcName, Type ret, params Type[] args)
+        {
+            MethodInfo mi   = Dynamic.GetMethodInfo(lpProcName, ret, args);
+            TDyn dyn        = bind(mi, lpProcName, Convention);
+
+            return delegate (object[] _args) {
+                return (T)dyn.dynamic.Invoke(null, _args);
+            };
+        }
+
+        /// <summary>
+        /// Alias `bind&lt;object&gt;(string func, Type ret, params Type[] args)`
+        /// Binds the exported C API Function.
+        /// </summary>
+        /// <param name="func">The name of exported C API function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Method bind(string func, Type ret, params Type[] args)
+        {
+            return bind<object>(func, ret, args);
+        }
+
+        /// <summary>
+        /// Binds the exported C API Function.
+        /// </summary>
+        /// <typeparam name="T">The return type for new Delegate should be as T type.</typeparam>
+        /// <param name="func">The name of exported C API function.</param>
+        /// <param name="ret">The type of return value.</param>
+        /// <param name="args">The type of arguments.</param>
+        /// <returns>Delegate of exported function.</returns>
+        public Method<T, object> bind<T>(string func, Type ret, params Type[] args)
+        {
+            return bindFunc<T>(funcName(func), ret, args);
+        }
+
         /// <summary>
         /// Returns full name of exported function.
         /// </summary>
diff --git a/Conari/Types/Methods/Method.cs b/Conari/Types/Methods/Method.cs
new file mode 100644
index 0000000..f19938c
--- /dev/null
+++ b/Conari/Types/Methods/Method.cs
@@ -0,0 +1,32 @@
+/*
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2016  Denis Kuzmin <entry.reg@gmail.com>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+*/
+
+namespace net.r_eg.Conari.Types.Methods
+{
+    /// <typeparam name="TRes">The type of return value.</typeparam>
+    /// <typeparam name="T">The type of arguments.</typeparam>
+    /// <param name="args">Argument list.</param>
+    /// <returns>Return value.</returns>
+    public delegate TRes Method<out TRes, T>(params T[] args);
+}
diff --git a/ConariTest/BindingTest.cs b/ConariTest/BindingTest.cs
index 8c434e3..74d673a 100644
--- a/ConariTest/BindingTest.cs
+++ b/ConariTest/BindingTest.cs
@@ -150,6 +150,91 @@ public void basicTest11()
             }
         }
 
+        [TestMethod]
+        public void basicTest12()
+        {
+            using(var l = new ConariL(UNLIB_DLL))
+            {
+                Assert.AreEqual(7, l.bindFunc<int>("get_VarSeven", typeof(int))());
+                Assert.AreEqual(null, l.bind("set_VarSeven", typeof(void), typeof(int))(5));
+                Assert.AreEqual(5, l.bind<int>("get_VarSeven", typeof(int))());
+                Assert.AreEqual(null ,l.bind("reset_VarSeven", null)());
+                Assert.AreEqual(-1, (int)l.bind("get_VarSeven", typeof(int))());
+            }
+        }
+
+        [TestMethod]
+        public void basicTest13()
+        {
+            using(var l = new ConariL(UNLIB_DLL))
+            {
+                Assert.AreEqual(7, l.bind<Func<int>>("get_VarSeven")());
+
+                l.bind<Action<int>>("set_VarSeven")(5);
+                Assert.AreEqual(5, l.bind<int>("get_VarSeven", typeof(int))());
+
+                l.bind("reset_VarSeven")();
+                Assert.AreEqual(-1, l.bind<Func<int>>("get_VarSeven")());
+            }
+        }
+
+        [TestMethod]
+        public void basicTest14()
+        {
+            using(var l = new ConariL(UNLIB_DLL))
+            {
+                Assert.AreEqual(7, l.DLR.get_VarSeven<int>());
+                Assert.AreEqual(null, l.DLR.set_VarSeven(5));
+                Assert.AreEqual(5, l.DLR.get_VarSeven<int>());
+                Assert.AreEqual(null ,l.DLR.reset_VarSeven());
+                Assert.AreEqual(-1, l.DLR.get_VarSeven<int>());
+            }
+        }
+
+        [TestMethod]
+        public void basicTest15()
+        {
+            using(var l = new ConariL(UNLIB_DLL))
+            {
+                Assert.AreEqual(7, l.bind(Dynamic.GetMethodInfo(typeof(int)), "get_VarSeven")
+                                        .dynamic
+                                        .Invoke(null, null));
+
+                Assert.AreEqual(null, l.bind(Dynamic.GetMethodInfo(typeof(void), typeof(int)), "set_VarSeven")
+                                        .dynamic
+                                        .Invoke(null, new object[] { 5 }));
+
+                Assert.AreEqual(5, l.bind(Dynamic.GetMethodInfo(typeof(int)), "get_VarSeven")
+                                        .dynamic
+                                        .Invoke(null, new object[0]));
+
+                Assert.AreEqual(null, l.bind(Dynamic.GetMethodInfo(null), "reset_VarSeven")
+                                        .dynamic
+                                        .Invoke(null, null));
+
+                Assert.AreEqual(-1, l.bind(Dynamic.GetMethodInfo(typeof(int)), "get_VarSeven")
+                                        .dynamic
+                                        .Invoke(null, null));
+            }
+        }
+
+        [TestMethod]
+        public void namingTest1()
+        {
+            using(var l = new ConariL(UNLIB_DLL, "apiprefix_"))
+            {
+                Assert.AreEqual(4, l.DLR.GetMagicNum<int>());
+
+                Assert.AreEqual(4, l.bind<Func<int>>("GetMagicNum")());
+                Assert.AreEqual(-1, l.bindFunc<Func<int>>("GetMagicNum")());
+
+                Assert.AreEqual(-1, l.bind(Dynamic.GetMethodInfo(typeof(int)), "GetMagicNum").dynamic.Invoke(null, null));
+
+                Assert.AreEqual(-1, l.bindFunc<int>("GetMagicNum", typeof(int))());
+                Assert.AreEqual(4, l.bind<int>("GetMagicNum", typeof(int))());
+            }
+        }
+
         [TestMethod]
         public void manglingTest1()
         {
diff --git a/UnLib/UnLibAPI.cpp b/UnLib/UnLibAPI.cpp
index 71ce45c..860ecf2 100644
--- a/UnLib/UnLibAPI.cpp
+++ b/UnLib/UnLibAPI.cpp
@@ -28,6 +28,33 @@ namespace NS_UNLIB_API_
         return "Hello World !";
     }
 
+    int _varSevenData = 7;
+    LIBAPI int get_VarSeven()
+    {
+        return _varSevenData;
+    }
+
+    LIBAPI void set_VarSeven(int v)
+    {
+        _varSevenData = v;
+    }
+
+    LIBAPI void reset_VarSeven()
+    {
+        _varSevenData = -1;
+    }
+
+    /* naming */
+
+    LIBAPI int GetMagicNum()
+    {
+        return -1;
+    }
+
+    LIBAPI int apiprefix_GetMagicNum()
+    {
+        return 4;
+    }
 
     /* mangling */
 
diff --git a/UnLib/UnLibAPI.h b/UnLib/UnLibAPI.h
index eb74ae9..425c4b2 100644
--- a/UnLib/UnLibAPI.h
+++ b/UnLib/UnLibAPI.h
@@ -12,6 +12,14 @@ namespace NS_UNLIB_API_
     LIBAPI bool get_False();
     LIBAPI unsigned short int get_Seven();
     LIBAPI const char* get_HelloWorld();
+    LIBAPI int get_VarSeven();
+    LIBAPI void set_VarSeven(int v);
+    LIBAPI void reset_VarSeven();
+
+    /* naming */
+
+    LIBAPI int GetMagicNum();
+    LIBAPI int apiprefix_GetMagicNum();
 
 
     /* mangling */