public void GetInstance(IFormatProvider formatProvider, NumberFormatInfo expected)
        {
            NumberFormatInfo nfi = NumberFormatInfo.GetInstance(formatProvider);

            Assert.Equal(expected.CurrencyDecimalDigits, nfi.CurrencyDecimalDigits);
            Assert.Equal(expected.CurrencyDecimalSeparator, nfi.CurrencyDecimalSeparator);
            Assert.Equal(expected.CurrencyGroupSeparator, nfi.CurrencyGroupSeparator);
            Assert.Equal(expected.CurrencyGroupSizes, nfi.CurrencyGroupSizes);
            Assert.Equal(expected.CurrencyNegativePattern, nfi.CurrencyNegativePattern);
            Assert.Equal(expected.CurrencyPositivePattern, nfi.CurrencyPositivePattern);
            Assert.Equal(expected.CurrencySymbol, nfi.CurrencySymbol);
            Assert.Equal(expected.NaNSymbol, nfi.NaNSymbol);
            Assert.Equal(expected.NegativeInfinitySymbol, nfi.NegativeInfinitySymbol);
            Assert.Equal(expected.NegativeSign, nfi.NegativeSign);
            Assert.Equal(expected.NumberDecimalDigits, nfi.NumberDecimalDigits);
            Assert.Equal(expected.NumberDecimalSeparator, nfi.NumberDecimalSeparator);
            Assert.Equal(expected.NumberGroupSeparator, nfi.NumberGroupSeparator);
            Assert.Equal(expected.NumberGroupSizes, nfi.NumberGroupSizes);
            Assert.Equal(expected.NumberNegativePattern, nfi.NumberNegativePattern);
            Assert.Equal(expected.PercentDecimalDigits, nfi.PercentDecimalDigits);
            Assert.Equal(expected.PercentDecimalSeparator, nfi.PercentDecimalSeparator);
            Assert.Equal(expected.PercentGroupSeparator, nfi.PercentGroupSeparator);
            Assert.Equal(expected.PercentGroupSizes, nfi.PercentGroupSizes);
            Assert.Equal(expected.PercentNegativePattern, nfi.PercentNegativePattern);
            Assert.Equal(expected.PercentPositivePattern, nfi.PercentPositivePattern);
            Assert.Equal(expected.PercentSymbol, nfi.PercentSymbol);
            Assert.Equal(expected.PositiveInfinitySymbol, nfi.PositiveInfinitySymbol);
            Assert.Equal(expected.PerMilleSymbol, nfi.PerMilleSymbol);
            Assert.Equal(expected.PositiveSign, nfi.PositiveSign);
        }
		/// <summary> Initializes all readonly configuration values </summary>
		static Configuration()
		{
			// Serializer:
			Binary = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
			Binary.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
			Binary.FilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;
			Binary.TypeFormat = System.Runtime.Serialization.Formatters.FormatterTypeStyle.TypesWhenNeeded;

			// DEFUALT FORMATTING
			FORMAT_DEFAULT		= LogUtils.PrepareFormatString("[{ManagedThreadId:D2}] {Level,8} - {Message}");// <- this can NOT contain expressions
			FORMAT_METHOD		= LogUtils.PrepareFormatString("{MethodType:%s.}{MethodName}{MethodArgs:(%s)}");
			FORMAT_LOCATION		= LogUtils.PrepareFormatString("{LogCurrent:   executing %s}{Method:   at %s@}{IlOffset:?}{FileLocation}");
			FORMAT_FILELINE		= LogUtils.PrepareFormatString("{FileName: in %s:line }{FileLine:?}");
			FORMAT_FULLMESSAGE	= LogUtils.PrepareFormatString("{Message}{Location}{Exception}");
			FormatProvider = new EventDataFormatter();

			CSharpTest.Net.Utils.ProcessInfo info = new CSharpTest.Net.Utils.ProcessInfo();
			ProcessId = info.ProcessId;
			ProcessName = info.ProcessName;
			AppDomainName = info.AppDomainName;
			EntryAssembly = info.EntryAssembly.GetName().Name;
			IsDebugging = info.IsDebugging;

			DefaultLogFile = info.DefaultLogFile.Insert(info.DefaultLogFile.LastIndexOf('.'), "{0}");
		}
        /// <summary>
        /// Construct a sink that saves logs to the specified storage account. Properties are being send as data and the level is used as tag.
        /// </summary>
        /// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        ///  <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
        public LogglySink(IFormatProvider formatProvider, int batchSizeLimit, TimeSpan period)
            : base (batchSizeLimit, period)
        {
            _formatProvider = formatProvider;

            _client = new LogglyClient();
        }
	// Parsing methods.
	public static short Parse(String s, NumberStyles style,
							  IFormatProvider provider)
			{
				NumberParser.ValidateIntegerStyle(style);
				return Convert.ToInt16(NumberParser.ParseInt32
					(s, style, NumberFormatInfo.GetInstance(provider), 32768));
			}
 /// <summary>
 /// Initializes a new instance of the <see cref="DebuggerWriter"/> class with the specified level, category and format Repository.
 /// </summary>
 /// <param name="level">A description of the importance of the messages.</param>
 /// <param name="category">The category of the messages.</param>
 /// <param name="formatRepository">An <see cref="IFormatRepository"/> object that controls formatting.</param>
 public DebuggerWriter(int level, string category, IFormatProvider formatRepository)
     : base(formatRepository)
 {
     this.level = level;
     this.category = category;
     isOpen = true;
 }
Exemple #6
0
        /// <summary>Obtains the string representation of this Scea.VectorMath.BezierCurve structure 
        /// with the specified formatting information</summary>
        /// <param name="format">Standard numeric format string characters valid for a floating point</param>
        /// <param name="formatProvider">The culture specific formatting provider</param>
        /// <returns>A <see cref="T:System.String"></see> representing the 3D Bezier curve</returns> 
        public string ToString(string format, IFormatProvider formatProvider)
        {
            if (format == null && formatProvider == null)
                return m_ctrlPoints[0].X.ToString("R") + ", " + m_ctrlPoints[0].Y.ToString("R") + ", " + m_ctrlPoints[0].Z.ToString("R") + ", " +
                    m_ctrlPoints[1].X.ToString("R") + ", " + m_ctrlPoints[1].Y.ToString("R") + ", " + m_ctrlPoints[1].Z.ToString("R") + ", " +
                    m_ctrlPoints[2].X.ToString("R") + ", " + m_ctrlPoints[2].Y.ToString("R") + ", " + m_ctrlPoints[2].Z.ToString("R") + ", " +
                    m_ctrlPoints[3].X.ToString("R") + ", " + m_ctrlPoints[3].Y.ToString("R") + ", " + m_ctrlPoints[3].Z.ToString("R");

            return String.Format
           (
                "({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})",
                ((double)m_ctrlPoints[0].X).ToString(format, formatProvider),
                ((double)m_ctrlPoints[0].Y).ToString(format, formatProvider),
                ((double)m_ctrlPoints[0].Z).ToString(format, formatProvider),
                ((double)m_ctrlPoints[1].X).ToString(format, formatProvider),
                ((double)m_ctrlPoints[1].Y).ToString(format, formatProvider),
                ((double)m_ctrlPoints[1].Z).ToString(format, formatProvider),
                ((double)m_ctrlPoints[2].X).ToString(format, formatProvider),
                ((double)m_ctrlPoints[2].Y).ToString(format, formatProvider),
                ((double)m_ctrlPoints[2].Z).ToString(format, formatProvider),
                ((double)m_ctrlPoints[3].X).ToString(format, formatProvider),
                ((double)m_ctrlPoints[3].Y).ToString(format, formatProvider),
                ((double)m_ctrlPoints[3].Z).ToString(format, formatProvider)
           );

        }
        public bool LessThanEqualTo(string version, IFormatProvider provider)
        {
            Version v = ConvertToVersion(version, provider);

            return this._major < v.Major || (this._major == v.Major && this._minor < v.Minor) ||
                   (this._major == v.Major && this._minor == v.Minor && this._build < v._build);
        }
Exemple #8
0
        internal FormatHelper(StringBuilder result, IFormatProvider provider, string format, object[] args)
        {
            if (format == null)
                throw new ArgumentNullException("format");
            if (args == null)
                throw new ArgumentNullException("args");
            
            this.result = result;
            this.provider = provider;
            this.format = format;
            this.args = args;
            this.numberOfArguments = args.Length;

            if (result == null)
            {
                // Try to approximate the size of result to avoid reallocations
                int i, len;

                len = 0;
                var argLength = args.Length;
                for (i = 0; i < argLength; ++i)
                {
                    string s = GetArg(i) as string;
                    if (s != null)
                        len += s.Length;
                    else
                        break;
                }
                this.result = new StringBuilder(len + format.Length);
            }
        }
Exemple #9
0
        /// <summary>
        /// Default ctor
        /// </summary>
        internal FormatHelper(StringBuilder result, IFormatProvider provider, string format, params object[] args)
        {
            this.result = result;
            this.provider = provider;
            this.format = format;
            this.args = args;
            if (format == null)
                throw new ArgumentNullException("format");
            if (args == null)
                throw new ArgumentNullException("args");

            if (this.result == null)
            {
                /* Try to approximate the size of result to avoid reallocations */
                int i, len;

                len = 0;
                for (i = 0; i < args.Length; ++i)
                {
                    string s = args[i] as string;
                    if (s != null)
                        len += s.Length;
                    else
                        break;
                }
                if (i == args.Length)
                    this.result = new StringBuilder(len + format.Length);
                else
                    this.result = new StringBuilder();
            }
        }
Exemple #10
0
        /// <summary>
        /// Construct a <see cref="JsonFormatter"/>.
        /// </summary>
        /// <param name="omitEnclosingObject">If true, the properties of the event will be written to
        /// the output without enclosing braces. Otherwise, if false, each event will be written as a well-formed
        /// JSON object.</param>
        /// <param name="closingDelimiter">A string that will be written after each log event is formatted.
        /// If null, <see cref="Environment.NewLine"/> will be used. Ignored if <paramref name="omitEnclosingObject"/>
        /// is true.</param>
        /// <param name="renderMessage">If true, the message will be rendered and written to the output as a
        /// property named RenderedMessage.</param>
        /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
        public JsonFormatter(
            bool omitEnclosingObject = false,
            string closingDelimiter = null,
            bool renderMessage = false,
            IFormatProvider formatProvider = null)
        {
            _omitEnclosingObject = omitEnclosingObject;
            _closingDelimiter = closingDelimiter ?? Environment.NewLine;
            _renderMessage = renderMessage;
            _formatProvider = formatProvider;

            _literalWriters = new Dictionary<Type, Action<object, bool, TextWriter>>
            {
                { typeof(bool), (v, q, w) => WriteBoolean((bool)v, w) },
                { typeof(char), (v, q, w) => WriteString(((char)v).ToString(), w) },
                { typeof(byte), WriteToString },
                { typeof(sbyte), WriteToString },
                { typeof(short), WriteToString },
                { typeof(ushort), WriteToString },
                { typeof(int), WriteToString },
                { typeof(uint), WriteToString },
                { typeof(long), WriteToString },
                { typeof(ulong), WriteToString },
                { typeof(float), WriteToString },
                { typeof(double), WriteToString },
                { typeof(decimal), WriteToString },
                { typeof(string), (v, q, w) => WriteString((string)v, w) },
                { typeof(DateTime), (v, q, w) => WriteDateTime((DateTime)v, w) },
                { typeof(DateTimeOffset), (v, q, w) => WriteOffset((DateTimeOffset)v, w) },
                { typeof(ScalarValue), (v, q, w) => WriteLiteral(((ScalarValue)v).Value, w) },
                { typeof(SequenceValue), (v, q, w) => WriteSequence(((SequenceValue)v).Elements, w) },
                { typeof(DictionaryValue), (v, q, w) => WriteDictionary(((DictionaryValue)v).Elements, w) },
                { typeof(StructureValue), (v, q, w) => WriteStructure(((StructureValue)v).TypeTag, ((StructureValue)v).Properties, w) },
            };
        }
        /// <summary>
        /// Adds a sink that writes log events as documents to a MongoDb database.
        /// </summary>
        /// <param name="loggerConfiguration">The logger configuration.</param>
        /// <param name="databaseUrl">The URL of a created MongoDB collection that log events will be written to.</param>
        /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
        /// <param name="cappedMaxSizeMb">Max total size in megabytes of the created capped collection. (Default: 50mb)</param>
        /// <param name="cappedMaxDocuments">Max number of documents of the created capped collection.</param>
        /// <param name="collectionName">Name of the collection. Default is "log".</param>
        /// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
        /// <returns>Logger configuration, allowing configuration to continue.</returns>
        /// <exception cref="ArgumentNullException">A required parameter is null.</exception>
        public static LoggerConfiguration MongoDBCapped(
            this LoggerSinkConfiguration loggerConfiguration,
            string databaseUrl,
            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
            long cappedMaxSizeMb = 50,
            long? cappedMaxDocuments = null,
            string collectionName = null,
            int batchPostingLimit = MongoDBSink.DefaultBatchPostingLimit,
            TimeSpan? period = null,
            IFormatProvider formatProvider = null)
        {
            if (loggerConfiguration == null) throw new ArgumentNullException("loggerConfiguration");
            if (databaseUrl == null) throw new ArgumentNullException("databaseUrl");

            var optionsBuilder = CollectionOptions.SetCapped(true).SetMaxSize(cappedMaxSizeMb * 1024 * 1024);

            if (cappedMaxDocuments.HasValue)
            {
                optionsBuilder = optionsBuilder.SetMaxDocuments(cappedMaxDocuments.Value);
            }

            var defaultedPeriod = period ?? MongoDBSink.DefaultPeriod;
            return loggerConfiguration.Sink(
                new MongoDBSink(
                    databaseUrl,
                    batchPostingLimit,
                    defaultedPeriod,
                    formatProvider,
                    collectionName ?? MongoDBSink.DefaultCollectionName,
                    optionsBuilder),
                restrictedToMinimumLevel);
        }
        public static string NamedFormat(string format, IFormatProvider provider, object formatObject, bool throwExceptionIfNotFound)
        {
            if (format == null)
                throw new ArgumentNullException("format");

            Regex r = new Regex(@"(?<start>\{)+(?<property>[\w\.\[\]]+)(?<format>:[^}]+)?(?<end>\})+",
                RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

            List<object> formatValues = new List<object>();
            string rewrittenFormat = r.Replace(format, delegate(Match m)
            {
                Group startGroup = m.Groups["start"];
                Group propertyGroup = m.Groups["property"];
                Group formatGroup = m.Groups["format"];
                Group endGroup = m.Groups["end"];

                string propertyName = propertyGroup.Value;

                formatValues.Add(GetObjectValue(propertyName, formatObject, throwExceptionIfNotFound));

                return new string('{', startGroup.Captures.Count) + (formatValues.Count - 1) + formatGroup.Value
                  + new string('}', endGroup.Captures.Count);
            });

            return string.Format(provider, rewrittenFormat, formatValues.ToArray());
        }
        public static string FormatWith(this string format, IFormatProvider provider, params object[] args)
        {
            if (format == null)
                throw new ArgumentNullException("format");

            return string.Format(provider, format, args);
        }
 public static LoggerConfiguration Log4Net(
     this LoggerSinkConfiguration loggerConfiguration,
     LogEventLevel restrictedToMinimumLevel,
     IFormatProvider formatProvider)
 {
     return loggerConfiguration.Log4Net(null, restrictedToMinimumLevel, formatProvider);
 }
 public StringWriter(StringBuilder sb, IFormatProvider formatProvider) : base(formatProvider) {
     if (sb==null)
         throw new ArgumentNullException("sb", Environment.GetResourceString("ArgumentNull_Buffer"));
     Contract.EndContractBlock();
     _sb = sb;
     _isOpen = true;
 }
Exemple #16
0
        /// <summary>
        /// Replacement for the String.Format method, that throws an exception
        /// when the count of arguments does not match the count of placeholders.
        /// <para>
        /// If format and/or arguments are null then still a string is returned.
        /// </para>
        /// </summary>
        /// <param name="formatProvider">
        /// The format Provider.
        /// </param>
        /// <param name="format">
        /// The format string.
        /// </param>
        /// <param name="args">
        /// The arguments to the format string..
        /// </param>
        /// <returns>
        /// Returns the fully formatted string, if successful In case of
        /// an error, the format string and all parameters added in a list
        /// will be returned.
        /// </returns>
        /// <remarks>
        /// Tries to format with String.Format. In case of an Exception the
        /// original format string and all parameters added in a list will
        /// be returned.
        /// </remarks>
        public static string SecureFormat(IFormatProvider formatProvider, string format, params object[] args)
        {
            if (format == null) 
            {
                // no format string
                return string.Empty;
            }

            // no arguments, just use format
            if (args == null) 
            {
                return format;
            }
            
            try
            {
                return string.Format(formatProvider, format, args);
            }
            catch (FormatException)
            {
                string result = "!!! FORMAT ERROR !!!! " + format + ": ";

                return args.Aggregate(result, (current, arg) => current + (arg + ", "));
            }
        }
 public string Format(string format, object arg, IFormatProvider formatProvider)
 {
     if (arg != null)
     {
         string fmt;
         switch (format)
         {
             case "S": // second
                 fmt = String.Format(new HMSFormatter("{0} seconds", "{0} second"), "{0}", arg);
                 break;
             case "M": // minute
                 fmt = String.Format(new HMSFormatter("{0} minutes", "{0} minute"), "{0}", arg);
                 break;
             case "H": // hour
                 fmt = String.Format(new HMSFormatter("{0} hours", "{0} hour"), "{0}", arg);
                 break;
             case "D": // day
                 fmt = String.Format(new HMSFormatter("{0} days", "{0} day"), "{0}", arg);
                 break;
             default:
                 // plural/ singular
                 fmt = String.Format((int)arg > 1 ? _plural : _singular, arg);  // watch the cast to int here...
                 break;
         }
         return fmt;
     }
     return String.Format(format, arg);
 }
        public string Format(string format, object arg, IFormatProvider provider)
        {
            if (arg == null || format != "Hx")
                return String.Format(parent,"{0:" + format + "}", arg);
            StringBuilder hexString = new StringBuilder();
            Stack<int> stack = new Stack<int>();
            int popped,delta, dec, providerBase = 16;
            try
            {
                dec = (int)arg;
            }
            catch (InvalidCastException ex)
            {

                throw new InvalidCastException("DecimalToHexProvider must recieve numerical type",ex);
            }

            while (dec != 0)
            {
                stack.Push(dec);
                dec /= providerBase;
            }
            delta = popped = stack.Pop();
            hexString.Append(hexCharacters[delta]);
            while (stack.Count > 0)
            {

                delta = stack.Peek() - popped * providerBase;
                hexString.Append(hexCharacters[delta]);
                popped = stack.Pop();

            }
            return hexString.ToString();
        }
		internal static String Format(Exception exception, IFormatProvider formatProvider)
		{
			if (exception == null)
				return null;

			// push all inner exceptions onto stack
			var exceptionStack = new Stack<Exception>();
			var currentException = exception;
			while (currentException != null)
			{
				exceptionStack.Push(currentException);
				currentException = currentException.InnerException;
			}

			// go through inner exceptions in reverse order
			var sb = new StringBuilder();
			for (Int32 i = 1; exceptionStack.Count > 0; i++)
			{
				currentException = exceptionStack.Pop();
				FormatSingleException(formatProvider, sb, currentException, i);
			}

			// that's it; return result
			return sb.ToString();
		}
Exemple #20
0
        public static String ToString(Double value, SIUnit unit, String format, IFormatProvider formatProvider)
        {
            var unitStr = unit.Symbol;

            if (value != 0)
            {
                var scale = 0;
                var log10 = Math.Log10(value);

                if (log10 < 0)
                {
                    value = MakeLarger(value, unit, out scale);
                }
                else if (log10 > 0)
                {
                    value = MakeSmaller(value, unit, out scale);
                }

                if (scale != 0)
                {
                    unitStr = Prefixes[scale].Symbol + unit.Symbol;
                }
            }

            return String.Format(formatProvider, "{0} {1}", value, unitStr);
        }
Exemple #21
0
        /// <summary>
        /// Render the value to the output.
        /// </summary>
        /// <param name="output">The output.</param>
        /// <param name="format">A format string applied to the value, or null.</param>
        /// <param name="formatProvider">A format provider to apply to the value, or null to use the default.</param>
        /// <seealso cref="LogEventPropertyValue.ToString(string, IFormatProvider)"/>.
        public override void Render(TextWriter output, string format = null, IFormatProvider formatProvider = null)
        {
            if (output == null) throw new ArgumentNullException(nameof(output));

            if (TypeTag != null)
            {
                output.Write(TypeTag);
                output.Write(' ');
            }
            output.Write("{ ");
            var allButLast = _properties.Length - 1;
            for (var i = 0; i < allButLast; i++)
            {
                var property = _properties[i];
                Render(output, property, formatProvider);
                output.Write(", ");
            }

            if (_properties.Length > 0)
            {
                var last = _properties[_properties.Length - 1];
                Render(output, last, formatProvider);
            }

            output.Write(" }");
        }
Exemple #22
0
        /// <summary>
        /// Converts the value of a specified object to an equivalent string
        /// representation using specified format and the invariant-culture
        /// formatting information.
        /// </summary>
        /// <param name="format">
        /// A format string containing formatting specifications.
        /// </param>
        /// <param name="arg">An object to format.</param>
        /// <param name="formatProvider">
        /// An IFormatProvider object that supplies format information about
        /// the current instance.
        /// </param>
        /// <returns>
        /// The string representation of the value of arg, formatted as specified
        /// by format and the invariant-culture.
        /// </returns>
        public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            if (format == null)
            {
                var convertible = arg as IConvertible;
                if (convertible != null)
                {
                    switch (convertible.GetTypeCode())
                    {
                        case TypeCode.Boolean:
                            return GetBool((bool)arg);

                        case TypeCode.DateTime:
                            return GetDateTime((DateTime)arg);

                        case TypeCode.Decimal:
                            return GetDecimal((decimal)arg);

                        case TypeCode.Double:
                            return GetFloatingPoint((double)arg);

                        case TypeCode.Single:
                            return GetFloatingPoint((float)arg);
                    }
                }
            }

            var formatter = new StringBuilder();
            formatter.AppendFormat(CultureInfo.InvariantCulture, "{0:" + format + "}", arg);
            return formatter.ToString();
        }
        public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            if (!(arg is DateTime)) throw new NotSupportedException();

            var dt = (DateTime)arg;

            string suffix;

            if (dt.Day % 10 == 1)
            {
                suffix = "st";
            }
            else if (dt.Day % 10 == 2)
            {
                suffix = "nd";
            }
            else if (dt.Day % 10 == 3)
            {
                suffix = "rd";
            }
            else
            {
                suffix = "th";
            }

            return string.Format("{1}{2} {0:MMMM} {0:yyyy}", arg, dt.Day, suffix);
        }
        /// <summary>
        /// Converts the value of a <see cref="TimeSpan"/> object to its equivalent natural string representation.
        /// </summary>
        /// <param name="timeSpan">A <see cref="TimeSpan"/>.</param>
        /// <param name="provider">An <see cref="IFormatProvider"/>.</param>
        /// <returns>The natural string representation of the <see cref="TimeSpan"/>.</returns>
        public static string ToNaturalString(this TimeSpan timeSpan, IFormatProvider provider)
        {
            List<string> parts = new List<string>();

            // Days
            if (timeSpan.Days != 0)
            {
                parts.Add(GetStringWithUnits(timeSpan.Days, "Day", provider));
            }

            // Hours
            if (timeSpan.Hours != 0 || parts.Count != 0)
            {
                parts.Add(GetStringWithUnits(timeSpan.Hours, "Hour", provider));
            }

            // Minutes
            if (timeSpan.Minutes != 0 || parts.Count != 0)
            {
                parts.Add(GetStringWithUnits(timeSpan.Minutes, "Minute", provider));
            }

            // Seconds
            parts.Add(GetStringWithUnits(timeSpan.Seconds, "Second", provider));

            // Join parts
            return string.Join(
                Resources.ResourceManager.GetString("TimeSpanExtensionsUnitSeparator", provider),
                parts);
        }
Exemple #25
0
        /// <summary>
        /// Construct a sink that saves logs to the specified storage account. Properties are being send as data and the level is used as tag.
        /// </summary>
        ///  <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
        /// <param name="logKey">The log key as found on the loggr website.</param>
        /// <param name="apiKey">The api key as found on the loggr website.</param>
        /// <param name="useSecure">Use a SSL connection. By default this is false.</param>
        /// <param name="userNameProperty">Specifies the property name to read the username from. By default it is UserName.</param>
        public LoggrSink(IFormatProvider formatProvider, string logKey, string apiKey, bool useSecure = false, string userNameProperty = "UserName")
        {
            _formatProvider = formatProvider;
            _userNameProperty = userNameProperty;

            _client = new LogClient(logKey, apiKey, useSecure);
        }
Exemple #26
0
        /// <summary>
        /// Returns the string representation of this object</summary>
        /// <param name="format">Optional standard numeric format string for a floating point number.
        /// If null, "R" is used for round-trip support in case the string is persisted.
        /// http://msdn.microsoft.com/en-us/library/vstudio/dwhawy9k(v=vs.100).aspx </param>
        /// <param name="formatProvider">Optional culture-specific formatting provider. This is usually
        /// a CultureInfo object or NumberFormatInfo object. If null, the current culture is used.
        /// Use CultureInfo.InvariantCulture for persistence.</param>
        /// <returns>String representation of object</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            string listSeparator = StringUtil.GetNumberListSeparator(formatProvider);

            // For historic reasons, use "R" for round-trip support, in case this string is persisted.
            if (format == null)
                format = "R";

            return String.Format(
                "{1}{0} {2}{0} {3}{0} {4}{0} {5}{0} {6}{0} {7}{0} {8}{0} {9}{0} {10}{0} {11}{0} {12}",
                listSeparator,
                m_ctrlPoints[0].X.ToString(format, formatProvider),
                m_ctrlPoints[0].Y.ToString(format, formatProvider),
                m_ctrlPoints[0].Z.ToString(format, formatProvider),
                m_ctrlPoints[1].X.ToString(format, formatProvider),
                m_ctrlPoints[1].Y.ToString(format, formatProvider),
                m_ctrlPoints[1].Z.ToString(format, formatProvider),
                m_ctrlPoints[2].X.ToString(format, formatProvider),
                m_ctrlPoints[2].Y.ToString(format, formatProvider),
                m_ctrlPoints[2].Z.ToString(format, formatProvider),
                m_ctrlPoints[3].X.ToString(format, formatProvider),
                m_ctrlPoints[3].Y.ToString(format, formatProvider),
                m_ctrlPoints[3].Z.ToString(format, formatProvider));

        }
Exemple #27
0
        /// <summary>
        ///     Converts the given string to a Int16.
        /// </summary>
        /// <exception cref="ArgumentNullException">The value can not be null.</exception>
        /// <exception cref="ArgumentNullException">The format provider can not be null.</exception>
        /// <param name="value">The string to convert.</param>
        /// <param name="formatProvider">The format provider.</param>
        /// <returns>Returns the converted Int16.</returns>
        public static Int16 ToInt16( this String value, IFormatProvider formatProvider )
        {
            value.ThrowIfNull( nameof( value ) );
            formatProvider.ThrowIfNull( nameof( formatProvider ) );

            return Convert.ToInt16( value, formatProvider );
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="DebugWriter"/> class with the specified level, category and format provider.
 /// </summary>
 /// <param name="level">A description of the importance of the messages.</param>
 /// <param name="category">The category of the messages.</param>
 /// <param name="formatProvider">An <see cref="IFormatProvider"/> object that controls formatting.</param>
 public DebugWriter(int level, string category, IFormatProvider formatProvider)
     : base(formatProvider)
 {
     this.level = level;
     this.category = category;
     this.isOpen = true;
 }
        public string ToString(string format, IFormatProvider formatProvider)
        {
            if (format.Contains(",") || format.Contains(";"))
            {
                string[] fieldArray = format.Split(';')[0].Split(',');
                string separator = format.Split(';')[1];

                List<string> fieldResults = new List<string>();

                foreach (string field in fieldArray)
                {
                    if (_dictionary.HasValueFor(field.Trim()))
                    {
                        fieldResults.Add(_dictionary.ValueFor(field.Trim()).ToString());
                    }
                }

                return string.Join(separator, fieldResults.ToArray());
            }
            else if (_dictionary.HasValueFor(format))
            {
                object value = _dictionary.ValueFor(format);

                return value == null ? null : value.ToString();
            }

            return null;
        }
 /// <summary>
 /// Parses this TextValue and converts it to a DateTime value.
 /// </summary>
 /// <returns>The parsed DateTime or January 1 1970 if the TextValue was not possible to parse.</returns>
 public override DateTime ToDateTime(IFormatProvider provider)
 {
     DateTime dt;
     if (!DateTime.TryParse(InternalValue, out dt))
         dt = new DateTime(1970, 1, 1);
     return dt;
 }
Exemple #31
0
 byte IConvertible.ToByte(IFormatProvider provider)
 {
     return(Convert.ToByte(_value));
 }
Exemple #32
0
 long IConvertible.ToInt64(IFormatProvider provider)
 {
     return(Convert.ToInt64(_value));
 }
Exemple #33
0
 int IConvertible.ToInt32(IFormatProvider provider)
 {
     return(Convert.ToInt32(_value));
 }
Exemple #34
0
 short IConvertible.ToInt16(IFormatProvider provider)
 {
     return(Convert.ToInt16(_value));
 }
Exemple #35
0
 double IConvertible.ToDouble(IFormatProvider provider)
 {
     return(Convert.ToDouble(_value));
 }
Exemple #36
0
 decimal IConvertible.ToDecimal(IFormatProvider provider)
 {
     return(Convert.ToDecimal(_value));
 }
Exemple #37
0
 DateTime IConvertible.ToDateTime(IFormatProvider provider)
 {
     throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to DateTime is not supported.");
 }
Exemple #38
0
 /// <summary>
 ///     Get string representation of value and unit. Using two significant digits after radix.
 /// </summary>
 /// <returns>String representation.</returns>
 /// <param name="provider">Format to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
 public string ToString([CanBeNull] IFormatProvider provider)
 {
     return(ToString(provider, 2));
 }
Exemple #39
0
 /// <summary>
 ///     Parse a unit string.
 /// </summary>
 /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
 /// <example>
 ///     Length.ParseUnit("m", new CultureInfo("en-US"));
 /// </example>
 /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
 /// <exception cref="UnitsNetException">Error parsing string.</exception>
 /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
 public static ElectricConductivityUnit ParseUnit(string str, IFormatProvider provider = null)
 {
     return(UnitParser.Default.Parse <ElectricConductivityUnit>(str, provider));
 }
Exemple #40
0
 bool IConvertible.ToBoolean(IFormatProvider provider)
 {
     throw new InvalidCastException($"Converting {typeof(ElectricConductivity)} to bool is not supported.");
 }
        public string Payment()
        {
            var             culture = CultureInfo.GetCultureInfo("en-US");
            IFormatProvider numericFormatProvider = culture.NumberFormat;


            var orderLayer = new OrderLayer();

            var itemList = new ItemList();

            itemList.items = new List <Item>();
            foreach (var line in orderLayer.Order.Lines)
            {
                var item = new Item
                {
                    currency    = "TRY",
                    description = line.ProductName,
                    name        = line.ProductName,
                    price       = line.Price.ToString("F2", numericFormatProvider),
                    quantity    = line.Quantity.ToString(),
                    sku         = line.ProductId.ToString(),
                    tax         = line.Tax.ToString("F2", numericFormatProvider)
                };
                itemList.items.Add(item);
            }
            var payer = new Payer {
                payment_method = "paypal"
            };
            var baseUrl  = HttpContext.Current.Request.Url.Scheme + "://" + HttpContext.Current.Request.Url.Authority + "/Order/PaymentCallback/Paypal";
            var redirUrl = new RedirectUrls
            {
                return_url = baseUrl + "?result=ok",
                cancel_url = baseUrl + "?result=fail"
            };
            var details = new Details
            {
                fee      = (orderLayer.Order.InstallmentFee + orderLayer.Order.PaymentFee).ToString("F2", numericFormatProvider),
                shipping = orderLayer.Order.ShipCost.ToString("F2", numericFormatProvider),
                tax      = orderLayer.Order.TaxTotal.ToString("F2", numericFormatProvider),
                subtotal = orderLayer.Order.OrderTotal.ToString("F2", numericFormatProvider)
            };
            var amount = new Amount
            {
                currency = "TRY",
                total    = orderLayer.Order.GrandTotal.ToString("F2", numericFormatProvider),
                details  = details
            };
            var transactionList = new List <Transaction>();

            transactionList.Add(
                new Transaction
            {
                invoice_number = orderLayer.Order.Id.ToString("00000000"),
                amount         = amount,
                item_list      = itemList
            }
                );
            var payment = new PayPal.Api.Payment
            {
                intent        = "sale",
                payer         = payer,
                transactions  = transactionList,
                redirect_urls = redirUrl
            };
            var paymenter = payment.Create(apiCtx);
            var links     = paymenter.links.GetEnumerator();

            while (links.MoveNext())
            {
                var link = links.Current;
                if (link.rel.ToLower().Trim().Equals("approval_url"))
                {
                    return(link.href);
                }
            }
            return(string.Empty);
        }
Exemple #42
0
 /// <summary>
 ///     Parse a unit string.
 /// </summary>
 /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
 /// <param name="unit">The parsed unit if successful.</param>
 /// <returns>True if successful, otherwise false.</returns>
 /// <example>
 ///     Length.TryParseUnit("m", new CultureInfo("en-US"));
 /// </example>
 /// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
 public static bool TryParseUnit(string str, IFormatProvider provider, out ElectricConductivityUnit unit)
 {
     return(UnitParser.Default.TryParse <ElectricConductivityUnit>(str, provider, out unit));
 }
 public static string FormatWith(this string format, IFormatProvider provider, object arg0, object arg1, object arg2, object arg3)
 {
     return(format.FormatWith(provider, new[] { arg0, arg1, arg2, arg3 }));
 }
Exemple #44
0
 /// <summary>
 ///     Get unit abbreviation string.
 /// </summary>
 /// <param name="unit">Unit to get abbreviation for.</param>
 /// <returns>Unit abbreviation string.</returns>
 /// <param name="provider">Format to use for localization. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
 public static string GetAbbreviation(ElectricConductivityUnit unit, [CanBeNull] IFormatProvider provider)
 {
     return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider));
 }
Exemple #45
0
 /// <internalonly/>
 DateTime IConvertible.ToDateTime(IFormatProvider provider)
 {
     throw new InvalidCastException(Environment.GetResourceString("InvalidCast_FromTo", "Boolean", "DateTime"));
 }
Exemple #46
0
 public string ToString(string format, IFormatProvider formatProvider)
 {
     return(string.Format("int3x2({0}, {1},  {2}, {3},  {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider)));
 }
Exemple #47
0
 /// <internalonly/>
 bool IConvertible.ToBoolean(IFormatProvider provider)
 {
     return(m_value);
 }
Exemple #48
0
 /// <internalonly/>
 Object IConvertible.ToType(Type type, IFormatProvider provider)
 {
     return(Convert.DefaultToType((IConvertible)this, type, provider));
 }
 public bool TryParseNumber(ParseType s, NumberStyles style, IFormatProvider provider, out ulong result) => ulong.TryParse(s, style, provider, out result);
Exemple #50
0
 /// <internalonly/>
 float IConvertible.ToSingle(IFormatProvider provider)
 {
     return(Convert.ToSingle(m_value));
 }
Exemple #51
0
 public static string Format(IFormatProvider provider, string format, params object[] args)
 {
     return(Default.Format(provider, format, args));
 }
Exemple #52
0
 public override string ToString(string format, IFormatProvider formatProvider)
 {
     return(string.Empty);
 }
        private Expression GetFunctionExpression <T>(string filter, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters, Type type, IFormatProvider formatProvider)
        {
            //Contract.Requires(filter != null);
            //Contract.Requires(sourceParameter != null);
            //Contract.Requires(lambdaParameters != null);

            var functionTokens = filter.GetFunctionTokens();

            if (functionTokens == null)
            {
                return(null);
            }

            var left = CreateExpression <T>(
                functionTokens.Left,
                sourceParameter,
                lambdaParameters,
                type ?? GetExpressionType <T>(functionTokens, sourceParameter, lambdaParameters),
                formatProvider);

            var right = left == null
                                                        ? null
                                                        : CreateExpression <T>(
                functionTokens.Right,
                sourceParameter,
                lambdaParameters,
                GetFunctionParameterType(functionTokens.Operation) ?? left.Type,
                formatProvider);

            return(left == null
                                ? null
                                : GetFunction(functionTokens.Operation, left, right, sourceParameter, lambdaParameters));
        }
 public bool TryParseNumber(ParseType s, NumberStyles style, IFormatProvider provider, out sbyte result) => sbyte.TryParse(s, style, provider, out result);
        private Expression GetArithmeticExpression <T>(string filter, ParameterExpression parameter, ICollection <ParameterExpression> lambdaParameters, Type type, IFormatProvider formatProvider)
        {
            //Contract.Requires(filter != null);
            //Contract.Requires(parameter != null);
            //Contract.Requires(lambdaParameters != null);

            var arithmeticToken = filter.GetArithmeticToken();

            if (arithmeticToken == null)
            {
                return(null);
            }

            var type1           = type ?? GetExpressionType <T>(arithmeticToken, parameter, lambdaParameters);
            var leftExpression  = CreateExpression <T>(arithmeticToken.Left, parameter, lambdaParameters, type1, formatProvider);
            var rightExpression = CreateExpression <T>(arithmeticToken.Right, parameter, lambdaParameters, type1, formatProvider);

            return(leftExpression == null || rightExpression == null
                                        ? null
                                        : GetLeftRightOperation(arithmeticToken.Operation, leftExpression, rightExpression));
        }
Exemple #56
0
 /// <summary>
 /// Returns a <see cref="System.String"/> that represents this instance.
 /// </summary>
 /// <param name="formatProvider">The format provider.</param>
 /// <returns>
 /// A <see cref="System.String"/> that represents this instance.
 /// </returns>
 public string ToString(IFormatProvider formatProvider)
 {
     return string.Format(formatProvider, "Center: {0}, Extents: {1}", Center.ToString(), Extents.ToString());
 }
        private Expression CreateExpression <T>(string filter, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters, Type type, IFormatProvider formatProvider)
        {
            //Contract.Requires(filter != null);
            //Contract.Requires(sourceParameter != null);
            //Contract.Requires(lambdaParameters != null);

            if (string.IsNullOrWhiteSpace(filter))
            {
                return(null);
            }

            var tokens = filter.GetTokens();

            if (tokens.Any())
            {
                return(GetTokenExpression <T>(sourceParameter, lambdaParameters, type, formatProvider, tokens));
            }

            if (string.Equals(filter, "null", StringComparison.OrdinalIgnoreCase))
            {
                return(Expression.Constant(null));
            }

            var stringMatch = StringRx.Match(filter);

            if (stringMatch.Success)
            {
                return(Expression.Constant(stringMatch.Groups[1].Value.Replace("''", "'"), typeof(string)));
            }

            if (NegateRx.IsMatch(filter))
            {
                var negateExpression = CreateExpression <T>(
                    filter.Substring(1),
                    sourceParameter,
                    lambdaParameters,
                    type,
                    formatProvider);

                //Contract.Assert(negateExpression != null);

                if (SupportsNegate(negateExpression.Type))
                {
                    return(Expression.Negate(negateExpression));
                }

                throw new InvalidOperationException("Cannot negate " + negateExpression);
            }

            var expression = GetAnyAllFunctionExpression <T>(filter, sourceParameter, lambdaParameters, formatProvider)
                             ?? GetPropertyExpression <T>(filter, sourceParameter, lambdaParameters)
                             ?? GetArithmeticExpression <T>(filter, sourceParameter, lambdaParameters, type, formatProvider)
                             ?? GetFunctionExpression <T>(filter, sourceParameter, lambdaParameters, type, formatProvider)
                             ?? GetParameterExpression(filter, type, formatProvider)
                             ?? GetBooleanExpression(filter, formatProvider);

            if (expression == null)
            {
                throw new InvalidOperationException("Could not create expression from: " + filter);
            }

            return(expression);
        }
        private Expression GetAnyAllFunctionExpression <T>(string filter, ParameterExpression sourceParameter, ICollection <ParameterExpression> lambdaParameters, IFormatProvider formatProvider)
        {
            //Contract.Requires(filter != null);
            //Contract.Requires(sourceParameter != null);
            //Contract.Requires(lambdaParameters != null);

            var functionTokens = filter.GetAnyAllFunctionTokens();

            if (functionTokens == null)
            {
                return(null);
            }

            var propertyExpression = GetPropertyExpression <T>(functionTokens.Left, sourceParameter, lambdaParameters);
            var leftType           = propertyExpression.Type;
            var left = CreateExpression <T>(
                functionTokens.Left,
                sourceParameter,
                lambdaParameters,
                leftType,
                formatProvider);

            // Create a new ParameterExpression from the lambda parameter and add to a collection to pass around
            var parameterName   = functionTokens.Right.Substring(0, functionTokens.Right.IndexOf(":", StringComparison.InvariantCultureIgnoreCase)).Trim();
            var lambdaParameter =
                Expression.Parameter(MethodProvider.GetIEnumerableImpl(leftType).GetGenericArguments()[0], parameterName);

            lambdaParameters.Add(lambdaParameter);
            var lambdaFilter = functionTokens.Right.Substring(functionTokens.Right.IndexOf(":", StringComparison.InvariantCultureIgnoreCase) + 1).Trim();
            var lambdaType   = GetFunctionParameterType(functionTokens.Operation)
                               ?? (left != null ? left.Type : null);

            var isLambdaAnyAllFunction = lambdaFilter.GetAnyAllFunctionTokens() != null;
            var right = isLambdaAnyAllFunction
                                ? GetAnyAllFunctionExpression <T>(lambdaFilter, lambdaParameter, lambdaParameters, formatProvider)
                                : CreateExpression <T>(lambdaFilter, sourceParameter, lambdaParameters, lambdaType, formatProvider);

            return(left == null
                                ? null
                                : GetFunction(functionTokens.Operation, left, right, sourceParameter, lambdaParameters));
        }
 bool IConvertible.ToBoolean(IFormatProvider provider)
 {
     return(Convert.ToBoolean(Value, provider));
 }
        private Expression GetTokenExpression <T>(ParameterExpression parameter, ICollection <ParameterExpression> lambdaParameters, Type type, IFormatProvider formatProvider, ICollection <TokenSet> tokens)
        {
            //Contract.Requires(tokens != null);
            //Contract.Requires(parameter != null);
            //Contract.Requires(lambdaParameters != null);

            string     combiner = null;
            Expression existing = null;

            foreach (var tokenSet in tokens)
            {
                if (string.IsNullOrWhiteSpace(tokenSet.Left))
                {
                    if (string.Equals(tokenSet.Operation, "not", StringComparison.OrdinalIgnoreCase))
                    {
                        var right = CreateExpression <T>(
                            tokenSet.Right,
                            parameter,
                            lambdaParameters,
                            type ?? GetExpressionType <T>(tokenSet, parameter, lambdaParameters),
                            formatProvider);

                        return(right == null
                                                                ? null
                                                                : GetOperation(tokenSet.Operation, null, right));
                    }

                    combiner = tokenSet.Operation;
                }
                else
                {
                    var left = CreateExpression <T>(
                        tokenSet.Left,
                        parameter,
                        lambdaParameters,
                        type ?? GetExpressionType <T>(tokenSet, parameter, lambdaParameters),
                        formatProvider);
                    if (left == null)
                    {
                        return(null);
                    }

                    var rightExpressionType = tokenSet.Operation == "and" ? null : left.Type;
                    var right = CreateExpression <T>(tokenSet.Right, parameter, lambdaParameters, rightExpressionType, formatProvider);

                    if (existing != null && !string.IsNullOrWhiteSpace(combiner))
                    {
                        var current = right == null ? null : GetOperation(tokenSet.Operation, left, right);
                        existing = GetOperation(combiner, existing, current ?? left);
                    }
                    else if (right != null)
                    {
                        existing = GetOperation(tokenSet.Operation, left, right);
                    }
                }
            }

            return(existing);
        }