/// <summary>
        /// default constructor with contract resolver
        /// </summary>
        /// <param name="resolver"></param>
        public CustomJsonConverter(IContractResolver resolver)
        {
            if (resolver == null)
                throw new ArgumentNullException("resolver");

            ContractResolver = resolver;
        }

 public CypherQuery(
     string queryText,
     IDictionary<string, object> queryParameters,
     CypherResultMode resultMode,
     IContractResolver contractResolver = null)
     : this(queryText, queryParameters, resultMode, CypherResultFormat.DependsOnEnvironment, contractResolver)
 {
 }

        protected void SetContractResolver(IContractResolver contractResolver)
        {
            _contractResolver = contractResolver;

            var cluster = ClusterHelper.Get();
            cluster.Configuration.DeserializationSettings.ContractResolver = contractResolver;
            cluster.Configuration.SerializationSettings.ContractResolver = contractResolver;
        }

        public JsonNetResult(Object jObject, IContractResolver contractResolver, params JsonConverter[] converters)
        {
            _jObject = jObject;

            _contractResolver = contractResolver;

            _converters = converters;
        }

        public JsonNetMemberNameResolver(IContractResolver contractResolver)
        {
            if (contractResolver == null)
            {
                throw new ArgumentNullException("contractResolver");
            }

            _contractResolver = contractResolver;
        }

        /// <summary>
        /// Constructorul principal care seteaza variabila readonly _responseValue serializata in metoda SerializeToStreamAsync si optional si contractResolver folosit pentru serializare
        /// </summary>
        /// <param name="responseValue">Obiectul care va fi serializat si scris in Stream de metoda SerializeToStreamAsync</param>
        /// <param name="contractResolver">Daca parametrul este null sau nespecificat se foloseste o instanta noua de tip DefaultContractResolver</param>
        public JsonContent(object responseValue, IContractResolver contractResolver = null)
        {
            _responseValue = responseValue;
            if (contractResolver == null)
                contractResolver = new DefaultContractResolver();
            _contractResolver = contractResolver;

            Headers.ContentType = new MediaTypeHeaderValue("application/json");
        }

        public JsonValue(IContractResolver resolver, object value)
        {
            if (value != null && !IsPrimitive(resolver, value.GetType()))
            {
                throw new ArgumentException("value must be a primitive recognized by Json.NET", "value");
            }

            _getValue = t => value;
        }

        protected void SetContractResolver(IContractResolver contractResolver)
        {
            _contractResolver = contractResolver;

            var cluster = ClusterHelper.Get();
            #pragma warning disable CS0618 // Type or member is obsolete
            cluster.Configuration.DeserializationSettings.ContractResolver = contractResolver;
            cluster.Configuration.SerializationSettings.ContractResolver = contractResolver;
            #pragma warning restore CS0618 // Type or member is obsolete
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="name">The friendly name of the format.</param>
        /// <param name="mediaTypeName">The correct media type name for content negotiation.</param>
        /// <param name="contractResolver">The resource contract resolver used to resolve the contracts at runtime.</param>
        protected HypermediaMediaTypeFormatter(string name, string mediaTypeName, IContractResolver contractResolver)
        {
            ContractResolver = contractResolver;

            SupportedMediaTypes.Clear();
            SupportedMediaTypes.Insert(0, new MediaTypeHeaderValue(mediaTypeName));

            MediaTypeMappings.Clear();
            MediaTypeMappings.Add(new QueryStringMapping("$format", name, mediaTypeName));
        }

        public SqLiteConfig(
            string databaseName,
            bool storeDateTimeAsTicks = true,
            IBlobSerializer serializer = null,
            IContractResolver resolver = null)
        {
            DatabaseName = databaseName;
            StoreDateTimeAsTicks = storeDateTimeAsTicks;

            BlobSerializer = serializer;
        }

 private static JsonConverter Build(Type type, Func<object, IEnumerable<object>> linkEnumerator, IContractResolver contractResolver)
 {
     var enumerable = type.GetInterface(typeof (IEnumerable<>).FullName);
     if (enumerable != null)
     {
         return Build(enumerable.GetGenericArguments().Single(), linkEnumerator, contractResolver);
     }
     var concreteType = typeof(LinkConverter<>).MakeGenericType(type);
     var newMethod = concreteType.GetMethod("New", BindingFlags.Static | BindingFlags.Public);
     return (JsonConverter)newMethod.Invoke(null, new object[] {linkEnumerator, contractResolver});
 }

 public SwaggerGenerator(
     IApiExplorer apiExplorer,
     IContractResolver jsonContractResolver,
     IDictionary<string, Info> apiVersions,
     SwaggerGeneratorOptions options = null)
 {
     _apiExplorer = apiExplorer;
     _jsonContractResolver = jsonContractResolver;
     _apiVersions = apiVersions;
     _options = options ?? new SwaggerGeneratorOptions();
 }

        public SQLiteConnectionString(string databasePath, bool storeDateTimeAsTicks,
            IBlobSerializer serializer = null,
            IContractResolver resolver = null)
        {
            ConnectionString = databasePath;
            StoreDateTimeAsTicks = storeDateTimeAsTicks;

            DatabasePath = databasePath;
            Serializer = serializer;
            Resolver = resolver ?? ContractResolver.Current;
        }

 private static void Add(Type type, IList<JsonConverter> converters, HashSet<Type> knownTypes, Func<object, IEnumerable<object>> linkEnumerator, HashSet<Type> done, IContractResolver contractResolver)
 {
     if (knownTypes.Contains(type))
     {
         converters.Add(Create(type, linkEnumerator, contractResolver));
     }
     done.Add(type);
     foreach (var property in type.GetProperties().Where(p => (!Ignore(p.PropertyType)) && (!done.Contains(p.PropertyType))))
     {
         Add(property.PropertyType, converters, knownTypes, linkEnumerator, done, contractResolver);
     }
 }

 /// <summary>
 /// Initializes a new instance of <see cref="NewtonsoftJsonSerializer"/> with a set of custom <see cref="JsonConverter"/> instances to be used by <see cref="ConverterContractResolver"/>.
 /// </summary>
 /// <param name="contractResolver">The underlying JSON.NET contract resolver.</param>
 public NewtonsoftJsonSerializer(IContractResolver contractResolver)
 {
     Serializer = new JsonSerializer
     {
         ContractResolver = contractResolver,
         DateFormatHandling = DateFormatHandling.IsoDateFormat,
         MissingMemberHandling = MissingMemberHandling.Ignore,
         DefaultValueHandling = DefaultValueHandling.Ignore,
         NullValueHandling = NullValueHandling.Ignore,
         TypeNameHandling = TypeNameHandling.Auto
     };
 }

        protected void InitializeCluster(IContractResolver contractResolver = null)
        {
            if (contractResolver != null)
            {
                _contractResolver = contractResolver;
            }

            var config = TestConfigurations.DefaultConfig();
            config.DeserializationSettings.ContractResolver = _contractResolver;
            config.SerializationSettings.ContractResolver = _contractResolver;
            ClusterHelper.Initialize(config);
        }

        /// <summary>
        /// Initializes a new instance of <see cref="ObjectAdapter"/>.
        /// </summary>
        /// <param name="contractResolver">The <see cref="IContractResolver"/>.</param>
        /// <param name="logErrorAction">The <see cref="Action"/> for logging <see cref="JsonPatchError"/>.</param>
        public ObjectAdapter(
            IContractResolver contractResolver,
            Action<JsonPatchError> logErrorAction)
        {
            if (contractResolver == null)
            {
                throw new ArgumentNullException(nameof(contractResolver));
            }

            ContractResolver = contractResolver;
            LogErrorAction = logErrorAction;
        }

        public static bool IsPrimitive(IContractResolver resolver, Type type)
        {
            if (resolver == null)
            {
                //get default from json serializer (since no public access to default resolver instance)
                resolver = new JsonSerializer().ContractResolver;
            }

            var contract = resolver.ResolveContract(type);

            return contract is JsonPrimitiveContract;
        }

 public CypherQuery(
     string queryText,
     IDictionary<string, object> queryParameters,
     CypherResultMode resultMode,
     CypherResultFormat resultFormat,
     IContractResolver contractResolver = null)
 {
     this.queryText = queryText;
     this.queryParameters = queryParameters;
     this.resultMode = resultMode;
     this.resultFormat = resultFormat;
     jsonContractResolver = contractResolver ?? GraphClient.DefaultJsonContractResolver;
 }

        public SQLiteConnectionString(string databasePath, bool storeDateTimeAsTicks,
            IBlobSerializer serializer = null,
            IContractResolver resolver = null,
            SQLiteOpenFlags? openFlags = null)
        {
            ConnectionString = databasePath;
            StoreDateTimeAsTicks = storeDateTimeAsTicks;

            DatabasePath = databasePath;
            Serializer = serializer;
            Resolver = resolver ?? ContractResolver.Current;
            OpenFlags = openFlags ?? SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
        }