public Name(string methodName, string className, MethodType type, bool interesting)
 {
     MethodName = methodName;
     ClassName = className;
     Type = type;
     Interesting = interesting;
 }

 public static string getOperationMethodName(this DbSetInfo dbSetInfo, MethodType methodType)
 {
     switch (methodType)
     {
         case MethodType.Refresh:
             if (string.IsNullOrWhiteSpace(dbSetInfo.refreshDataMethod))
                 return null;
             return GenerateMethodName(dbSetInfo.refreshDataMethod, dbSetInfo.dbSetName);
         case MethodType.Insert:
             if (string.IsNullOrWhiteSpace(dbSetInfo.insertDataMethod))
                 return null;
             return GenerateMethodName(dbSetInfo.insertDataMethod, dbSetInfo.dbSetName);
         case MethodType.Update:
             if (string.IsNullOrWhiteSpace(dbSetInfo.updateDataMethod))
                 return null;
             return GenerateMethodName(dbSetInfo.updateDataMethod, dbSetInfo.dbSetName);
         case MethodType.Delete:
             if (string.IsNullOrWhiteSpace(dbSetInfo.deleteDataMethod))
                 return null;
             return GenerateMethodName(dbSetInfo.deleteDataMethod, dbSetInfo.dbSetName);
         case MethodType.Validate:
             if (string.IsNullOrWhiteSpace(dbSetInfo.validateDataMethod))
                 return null;
             return GenerateMethodName(dbSetInfo.validateDataMethod, dbSetInfo.dbSetName);
         default:
             throw new DomainServiceException(string.Format("Invalid Method Type {0}", methodType));
     }
 }

 private static Database CreateDatabase(MethodType type)
 {
     switch (type)
     {
         case MethodType.One:
             {
                 // Should only exist one DatabaseProviderFactory object in your application,
                 // since all the Database objects are cached in the factory
                 var factory = new DatabaseProviderFactory();
                 return factory.CreateDefault();
             }
         case MethodType.Two:
             {
                 var factory = new DatabaseProviderFactory();
                 DatabaseFactory.SetDatabaseProviderFactory(factory);
                 return DatabaseFactory.CreateDatabase();
             }
         case MethodType.Three:
             {
                 var factory = new DatabaseProviderFactory();
                 DatabaseFactory.SetDatabaseProviderFactory(factory);
                 return DatabaseFactory.CreateDatabase("LocalDb");
             }
         case MethodType.Four:
             {
                 return new SqlDatabase(ConfigurationManager.ConnectionStrings["LocalDb"].ConnectionString);
             }
         default:
             throw new NotSupportedException();
     }
 }

 public ProxyMethodInfo(string methodName, string typeName, Type fakeType, MethodInfo fakeMethod, MethodType fakeMethodType)
     : this(methodName, typeName)
 {
     FakeMethodType = fakeMethodType;
     FakeMethod = fakeMethod;
     FakeType = fakeType;
 }

    public static void Request(MethodType method, string uri, string body, CallBack<string> callBack)
    {
        try
        {
            Init("8aa5b8b5-f769-11e3-954e-06a6fa0000b9", "6ef2e5c0-3ef1-11e4-ae91-06a6fa0000b9");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(APIEndpoint + uri);

            request.Method = method.ToString();
            request.ContentType = "applications/json";

            if (PlayerPrefs.HasKey("access_token"))
            request.Headers["Authorization"] = "Bearer " + PlayerPrefs.GetString("access_token");

            if(request.Method == "POST" || request.Method == "PUT")
            {
                StreamWriter writer = new StreamWriter(request.GetRequestStream());
                writer.Write(body);
                writer.Close();
            }

            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream dataStream = response.GetResponseStream();
            StreamReader reader = new StreamReader(dataStream);

            string responseFromServer = reader.ReadToEnd();

            callBack(responseFromServer);
        }
        catch(Exception e)
        {
            Debug.Log(e.Message);
        }
    }

 /// <summary>
 /// Generates the signature.
 /// </summary>
 /// <param name="t">The tokens.</param>
 /// <param name="httpMethod">The HTTP method.</param>
 /// <param name="url">The URL.</param>
 /// <param name="prm">The parameters.</param>
 /// <returns>The signature.</returns>
 internal static string GenerateSignature(Tokens t, MethodType httpMethod, Uri url, IEnumerable<KeyValuePair<string, string>> prm)
 {
     var key = Encoding.UTF8.GetBytes(
         string.Format("{0}&{1}", UrlEncode(t.ConsumerSecret),
                       UrlEncode(t.AccessTokenSecret)));
     var prmstr = prm.Select(x => new KeyValuePair<string, string>(UrlEncode(x.Key), UrlEncode(x.Value)))
         .Concat(
             url.Query.TrimStart('?').Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
                 .Select(x =>
                 {
                     var s = x.Split('=');
                     return new KeyValuePair<string, string>(s[0], s[1]);
                 })
         )
         .OrderBy(x => x.Key).ThenBy(x => x.Value)
         .Select(x => x.Key + "=" + x.Value)
         .JoinToString("&");
     var msg = Encoding.UTF8.GetBytes(
         string.Format("{0}&{1}&{2}",
             httpMethod.ToString().ToUpperInvariant(),
             UrlEncode(url.GetComponents(UriComponents.Scheme | UriComponents.UserInfo | UriComponents.Host | UriComponents.Port | UriComponents.Path, UriFormat.UriEscaped)),
             UrlEncode(prmstr)
         ));
     return Convert.ToBase64String(SecurityUtils.HmacSha1(key, msg));
 }

        public CommonParameters(MethodType method, bool verifyOriginator = false)
        {
            
            Id = RandomNumberGenerator.Instance.Next();

            MethodType = method;
            VerifyOriginator = verifyOriginator;
        }

        /// <summary>
        /// Initializes a new <see cref="Method"/> instance with the given parameters.
        /// </summary>
        /// <param name="moduleId">The ID of the module the symbol resides in.</param>
        /// <param name="type">The type of the method.</param>
        /// <param name="address">The start address of the method.</param>
        /// <param name="length">The length of the method, in bytes.</param>
        public Method( uint moduleId, MethodType type, uint address, uint length )
            : base(moduleId, address, length)
        {
            this.Type = type;

            //Debug.Assert( address % 4 == 0 );
            Debug.Assert( length % 4 == 0 );
        }

        public static List<string> CreateMethodParamList(MethodType Methodtype, string Tablename, List<string> Colnames, string Namespace)
        {
            List<string> lines = new List<string>();
            List<string> propertyInfos = new List<string>();

            var typeMap = Assembly.GetExecutingAssembly().GetTypes()
                          .Where(t => t.Namespace == Namespace)
                          .ToDictionary(t => t.Name, t => t,
                                        StringComparer.OrdinalIgnoreCase);

            Type type;
            if (typeMap.TryGetValue(Tablename.Trim(), out type))
            {
                try
                {
                    var cls = Activator.CreateInstance(type);
                    foreach (var prop in cls.GetType().GetProperties())
                    {
                        propertyInfos.Add(prop.Name);
                    }
                }
                catch(Exception ex)
                {
                    Console.WriteLine(string.Format("Error:{0}", ex));
                }
            }
            else
            {
                Console.WriteLine("Type not found");
            }

            var i = 0;
            foreach (var s in Colnames)
            {
                switch (Methodtype)
                {
                    case MethodType.Insert:
                        lines.Add(string.Format("fbCom.Parameters.AddWithValue(\"@{0}\", {1}.{2});", s, Tablename, propertyInfos[i]));
                        break;
                    case MethodType.Select:
                        lines.Add(string.Format("fbCom.Parameters.AddWithValue(\"@{0}\", {1});", s, propertyInfos[i].ToUpper()));
                        return lines;
                    //case MethodType.Update:
                    //    lines.Add(string.Format("fbCom.Parameters.AddWithValue(\"{0}\", {1}.{2});", s, Tablename, propertyInfos[i]));
                    //    break;
                    case MethodType.Delete:
                        lines.Add(string.Format("fbCom.Parameters.AddWithValue(\"@{0}\", {1});", s, propertyInfos[i].ToUpper()));
                        return lines;
                    case MethodType.None:
                        break;
                    default:
                        break;
                }
                
                i++;
            }
            return lines;
        }

 public PipelineException(PipelineErrorType errorType, string serviceName, string route, Uri requestUri, MethodType methodType, Exception innerException)
     : base(PipelineException.DefaultMessage, innerException)
 {
     this.errorType = errorType;
     this.serviceName = serviceName;
     this.route = route;
     this.requestUri = requestUri;
     this.methodType = methodType;
 }

 /// <summary>
 /// Creates a service object method with the given name, description and Methodtype
 /// </summary>
 /// <param name="name"></param>
 /// <param name="description"></param>
 /// <param name="methodType"></param>
 /// <returns></returns>
 public static Method CreateMethod(string name, string description, MethodType methodType)
 {
     Method m = new Method();
     m.Name = name;
     m.Type = methodType;
     m.MetaData.DisplayName = AddSpaceBeforeCaptialLetter(name);
     m.MetaData.Description = description;
     return m;
 }

    private NativeInvokerBytecodeGenerator(LambdaForm lambdaForm, MethodType invokerType)
    {
        if (invokerType != invokerType.basicType())
        {
            throw new BailoutException(Bailout.NotBasicType, invokerType);
        }
        this.lambdaForm = lambdaForm;
        this.invokerType = invokerType;
        this.delegateType = MethodHandleUtil.GetMemberWrapperDelegateType(invokerType);
        MethodInfo mi = MethodHandleUtil.GetDelegateInvokeMethod(delegateType);
        Type[] paramTypes = MethodHandleUtil.GetParameterTypes(typeof(object[]), mi);
        // HACK the code we generate is not verifiable (known issue: locals aren't typed correctly), so we stick the DynamicMethod into mscorlib (a security critical assembly)
        this.dm = new DynamicMethod(lambdaForm.debugName, mi.ReturnType, paramTypes, typeof(object).Module, true);
        this.ilgen = CodeEmitter.Create(this.dm);
        if (invokerType.parameterCount() > MethodHandleUtil.MaxArity)
        {
            this.packedArgType = paramTypes[paramTypes.Length - 1];
            this.packedArgPos = paramTypes.Length - 1;
        }
        else
        {
            this.packedArgPos = Int32.MaxValue;
        }

        locals = new CodeEmitterLocal[lambdaForm.names.Length];
        for (int i = lambdaForm._arity(); i < lambdaForm.names.Length; i++)
        {
            Name name = lambdaForm.names[i];
            if (name.index() != i)
            {
                throw new BailoutException(Bailout.PreconditionViolated, "name.index() != i");
            }
            switch (name.typeChar())
            {
                case 'L':
                    locals[i] = ilgen.DeclareLocal(Types.Object);
                    break;
                case 'I':
                    locals[i] = ilgen.DeclareLocal(Types.Int32);
                    break;
                case 'J':
                    locals[i] = ilgen.DeclareLocal(Types.Int64);
                    break;
                case 'F':
                    locals[i] = ilgen.DeclareLocal(Types.Single);
                    break;
                case 'D':
                    locals[i] = ilgen.DeclareLocal(Types.Double);
                    break;
                case 'V':
                    break;
                default:
                    throw new BailoutException(Bailout.PreconditionViolated, "Unsupported typeChar(): " + name.typeChar());
            }
        }
    }

 /// <summary>
 /// Creates a service object method with the given name, description and Methodtype
 /// </summary>
 /// <param name="name"></param>
 /// <param name="description"></param>
 /// <param name="methodType"></param>
 /// <returns></returns>
 public static Method CreateMethod(string name, string description, MethodType methodType)
 {
     Method m = new Method
     {
         Name = name,
         Type = methodType,
         MetaData = new MetaData(AddSpaceBeforeCaptialLetter(name), description)
     };
     return m;
 }

        public Method(MethodType methodType, Endpoint endpoint, Action<IRequestMessage, IResponseMessage> action)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action", "action cannot be null.");
            }

            this.Initialize(methodType, endpoint);
            this.requestResponseAction = action;
        }

        public FeedbackType(string name, int id, MethodInfo callback, MethodType methodType, List<FeedbackField> fields)
        {
            this.name = name;
            this.id = id;
            this.method = callback;
            this.fields = fields;

            methodHasTimestamp = (methodType & MethodType.Timestamp) != MethodType.None;
            methodHasMsgType = (methodType & MethodType.MessageType) != MethodType.None;
            methodIsObjectArray = (methodType & MethodType.ObjectArray) != MethodType.None;
        }

        /// <summary>
        ///     Initialisiert eine neue Instanz der <see cref="MethodCommand" /> Klasse.
        /// </summary>
        /// <param name="method">
        ///     The method.
        /// </param>
        /// <param name="context">
        ///     The context.
        /// </param>
        public MethodCommand([NotNull] MethodInfo method, [NotNull] WeakReference context)
        {
            Contract.Requires<ArgumentNullException>(method != null, "method");

            _method = method;
            _context = context;

            _methodType = (MethodType) method.GetParameters().Length;
            if (_methodType != MethodType.One) return;
            if (_method.GetParameters()[0].ParameterType != typeof (EventData)) _methodType = MethodType.EventArgs;
        }

 public RequestMessage(MethodType intMethod, string strURL)
 {
     // Asigna las propiedades
         Method = intMethod;
         URL = strURL;
     // Asigna los valores básicos
         ContentType = "text/xml";
     // Define los objetos
         UrlParameters = new ParameterDataCollection();
         QueryParameters = new ParameterDataCollection();
         Attachments = new AttachmentsCollection();
 }

 public void AddMethod(string name, string displayName, string description, MethodType k2Type, List<string> inputProps, List<string> requiredProps, List<string> returnProps)
 {
     SchemaMethod meth = new SchemaMethod();
     meth.Name = name;
     meth.DisplayName = displayName;
     meth.K2Type = k2Type;
     meth.Description = description;
     meth.InputProperties = inputProps;
     meth.RequiredProperties = requiredProps;
     meth.ReturnProperties = returnProps;
     SchemaMethods.Add(meth);
 }

        public WindowedSincUpsampler(int factor, int windowLength, MethodType method)
            : base(FilterType.WindowedSincUpsampler)
        {
            if (factor <= 1 || !IsPowerOfTwo(factor)) {
                throw new ArgumentException("factor must be power of two integer and larger than 1");
            }
            Factor = factor;

            WindowLength = windowLength;

            Method = method;
            mFirst = true;
        }

        public void AddMethod(int id, SimpleMethodInfo method, MethodType type)
        {
            IMonitorServiceCallback channel = GetCallbackChannel();

            if (!_clientIDs.ContainsKey(channel))
            {
                AddStatusText(string.Format("New Client (#{0})", _nextClientID));
                _clientIDs.Add(channel, _nextClientID++);
            }

            AddStatusText(string.Format("New Method (#{0}, {1})", _clientIDs[channel], id));
            _methods.Add(new ClientMethodInfo() { Callback = channel, ID = id, MethodInfo = method, ClientID = _clientIDs[channel], Type = type });
        }