You can specify a format string after an expression with a colon (`:`):

    var aNumberAsString = $&quot;{aDoubleValue:0.####}&quot;;

A colon after the variable specifies a format,

    Console.Write($&quot;{aDoubleValue:0.####}&quot;);

I have recently updated to the google play services library version 9.0.0, and I keep getting the following logcat message:

    05-19 23:07:30.023 19237-19508/? V/GoogleSignatureVerifier: options.developer.com.developeroptions signature not valid.  Found: 


While my app isn&#39;t using the google maps api but it is using the analytics, ads, and google plus apis.

The only mention in the documentation regarding the usage of the api key is when using google maps, or android places api.

I have also tried adding the &#39;com.google.android.geo.API_KEY&#39; with a correct key but it didn&#39;t help.

here is my gradle.build file:

    apply plugin: &#39;com.android.application&#39;
    
    android {
        compileSdkVersion 23
        buildToolsVersion &quot;23.0.3&quot;
    
        defaultConfig {
            applicationId &quot;options.developer.com.developeroptions&quot;
            minSdkVersion 9
            targetSdkVersion 23
            versionCode 23
            versionName &quot;1.06&quot;
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
            }
        }
    }
    
    
    dependencies {
        compile &#39;com.google.android.gms:play-services-plus:9.0.0&#39;
        compile &#39;com.android.support:appcompat-v7:23.2.0&#39;
        compile &#39;com.google.android.gms:play-services-analytics:9.0.0&#39;
        compile &#39;com.google.android.gms:play-services-ads:9.0.0&#39;
    }



GoogleSignatureVerifier signature not valid message (google play services 9.0.0)

I&#39;m not sure what&#39;s causing this issue, but in a project, I&#39;m building, the compiler is taking hours just to compile a module. The total size of my codebase is 352KB, but none of the modules are over 10KB large. I am using a Native port, but it&#39;s very trivial; I&#39;m just fetching `Date.now()` with it.

Is there anything well-known that would cause the elm compiler to take forever to compile? I don&#39;t have many dependencies, but I&#39;m using Html a lot. I would really appreciate any hints as to what would cause this.

# Edit

So it turns out __large case expressions__ will cause the optimizer to take a long time, as of 0.16. Here&#39;s the [discussion on Elm-Discuss](https://groups.google.com/forum/#!topic/elm-discuss/2ySK77lKYss) bringing up the issue, and a [gist of the nasty case match](https://gist.github.com/athanclark/0e29485cb245ff07a97730cfef365d10).

I guess to be verbose and to keep a carrot out there, why would elm&#39;s compiler take this route for case-matching? What&#39;s the underlying machinery going on here? Why would the compiler take longer than an hour for optimizing 60+ pattern matches on a case statement?

Elm Compiler running forever, computer just getting hot

I have used interpolated strings for messages containing `string` variables like `$&quot;{EmployeeName}, {Department}&quot;`. Now I want to use an interpolated string for showing a formatted `double`.

Example

    var aNumberAsString = aDoubleValue.ToString(&quot;0.####&quot;);

How can I write it as an interpolated string? Something like `$&quot;{aDoubleValue} ....&quot;`

C# 6 how to format double using interpolated string?

I have used interpolated strings for messages containing <code>string</code> variables like <code>$"{EmployeeName}, {Department}"</code>. Now I want to use an interpolated string for showing a formatted <code>double</code>.
Example
<pre><code class="hljs language-ini">var aNumberAsString = aDoubleValue.ToString("0.####");
</code></pre>
How can I write it as an interpolated string? Something like <code>$"{aDoubleValue} ...."</code>

Consider the following simple program:

    using System;
    using System.Diagnostics;
    
    class Program
    {
       private static void Main(string[] args)
       {
          const int size = 10000000;
          var array = new string[size];
    
          var str = new string(&#39;a&#39;, 100);
          var sw = Stopwatch.StartNew();
          for (int i = 0; i &lt; size; i++)
          {
             var str2 = new string(&#39;a&#39;, 100);
             //array[i] = str2; // This is slow
             array[i] = str; // This is fast
          }
          sw.Stop();
          Console.WriteLine(&quot;Took &quot; + sw.ElapsedMilliseconds + &quot;ms.&quot;);
       }
    }
If I run this, it&#39;s relatively fast.  If I uncomment the &quot;slow&quot; line and comment-out the &quot;fast&quot; line, it&#39;s more than 5x slower.  Note that in both situations it initializes the string &quot;str2&quot; inside the loop.  This is not optimized away in either case (this can be verified by looking at the IL or disassembly).

The code would seem to be doing about the same amount of work in either case.  It needs to allocate/initialize a string, and then assign a reference to an array location.  The only difference is whether that reference is the local var &quot;str&quot; or &quot;str2&quot;.

Why does it make such a large performance difference assigning the reference to &quot;str&quot; vs. &quot;str2&quot;?

If we look at the disassembly, there is a difference:

    (fast)
         var str2 = new string(&#39;a&#39;, 100);
    0000008e  mov         r8d,64h 
    00000094  mov         dx,61h 
    00000098  xor         ecx,ecx 
    0000009a  call        000000005E393928 
    0000009f  mov         qword ptr [rsp+58h],rax 
    000000a4  nop

    (slow)
         var str2 = new string(&#39;a&#39;, 100);
    00000085  mov         r8d,64h 
    0000008b  mov         dx,61h 
    0000008f  xor         ecx,ecx 
    00000091  call        000000005E383838 
    00000096  mov         qword ptr [rsp+58h],rax 
    0000009b  mov         rax,qword ptr [rsp+58h] 
    000000a0  mov         qword ptr [rsp+38h],rax

The &quot;slow&quot; version has two additional &quot;mov&quot; operations where the &quot;fast&quot; version just has a &quot;nop&quot;.

Can anyone explain what&#39;s happening here?  It&#39;s difficult to see how two extra mov operations can cause a &gt;5x slowdown, especially since I would expect the vast bulk of the time should be spend in the string initialization.  Thanks for any insights.


Why does a local var reference cause a large performance degradation?

At this point I&#39;m injecting things into my Controllers with ease, in some cases building my own ResolverServices class. _Life is good_.

What I cannot figure out how to do is get the framework to automatically inject into non-controller classes. What does work is having the framework automatically inject into my controller `IOptions`, which is effectively the configuration for my project:

    public class MessageCenterController : Controller
    {
        private readonly MyOptions _options;

        public MessageCenterController(IOptions&lt;MyOptions&gt; options)
        {
            _options = options.Value;
        }
    }

I&#39;m thinking whether I can do the same for for my own classes. I assume I&#39;m close when I mimic the controller, like this:

    public class MyHelper
    {
        private readonly ProfileOptions _options;

        public MyHelper(IOptions&lt;ProfileOptions&gt; options)
        {
            _options = options.Value;
        }

        public bool CheckIt()
        {
            return _options.SomeBoolValue;
        }
    }


I think where I&#39;m failing is when I call it like this:

    public void DoSomething()
    {
        var helper = new MyHelper(??????);

        if (helper.CheckIt())
        {
            // Do Something
        }
    }

The problem I have tracking this down is practically everything that talks about DI is talking about it at the controller level. I tried hunting down where it happens in the `Controller` object source code, but it gets kinda crazy in there.

I do know I can manually create an instance of IOptions&lt;ProfileOptions&gt; and pass it to the `MyHelper` constructor, but it seems like I should be able to get the framework do that since it works for `Controllers`.

Dependency Injection with classes other than a Controller class

How do I add or access an `app.config` file in Azure functions to add a database connection string? 

If you&#39;re not supposed to add an `app.config` and there is a better way to access an external database to execute the function please let me know best practices.  Thanks!

Azure Functions Database Connection String

In my web application I get the following error:

&gt; WebForms UnobtrusiveValidationMode requires a ScriptResourceMapping
&gt; for &#39;jquery&#39;. Please add a ScriptResourceMapping named
&gt; jquery(case-sensitive).
&gt; 
&gt; Description: An unhandled exception occurred during the execution of
&gt; the current web request. Please review the stack trace for more
&gt; information about the error and where it originated in the code. 
&gt; 
&gt; Exception Details: System.InvalidOperationException: WebForms
&gt; UnobtrusiveValidationMode requires a ScriptResourceMapping for
&gt; &#39;jquery&#39;. Please add a ScriptResourceMapping named
&gt; jquery(case-sensitive).

How can I solve it?


WebForms UnobtrusiveValidationMode requires a ScriptResourceMapping for jquery

Is there a logic to which constant I get if there are more than one enum constant that has the same value?

I tried the variations below, but couldn&#39;t get a reasonable logic.

&lt;h3&gt;Main Method:&lt;/h3&gt;

    public class Program
    {
    	public static void Main(string[] args)
    	{
    		Test a = 0;
    		Console.WriteLine(a);
    	}
    }

&lt;h3&gt;First try:&lt;/h3&gt;

    enum Test
    {
    	a1=0,
    	a2=0,
    	a3=0,
    	a4=0,
    }

Output:

    a2

&lt;h3&gt;Second try:&lt;/h3&gt;

    enum Test
    {
    	a1=0,
    	a2=0,
    	a3,
    	a4=0,
    }

Output:

    a4

&lt;h3&gt;Third try:&lt;/h3&gt;

    enum Test
    {
    	a1=0,
    	a2=0,
    	a3,
    	a4,
    }

Output:

    a2

&lt;h3&gt;Fourth try:&lt;/h3&gt;

    enum Test
    {
    	a1=0,
    	a2=0,
    	a3,
    	a4
    }

Output:

    a1


Which Enum constant will I get if the Enum values are same

I am getting the following error:

    Both assertEquals(Object, Object) in Assert and assertEquals(double, double) in Assert match

For this line of code in my `Junit` tests, note that `getScore`() returns a `double`: 

    assertEquals(2.5, person.getScore());

This is my assert import:

    import static org.junit.Assert.*;

What is causing this and how can I fix this?

Ambiguous method call Both assertEquals(Object, Object) in Assert and assertEquals(double, double) in Assert match:

My question is whether all integer values are guaranteed to have a perfect double representation. 

Consider the following code sample that prints &quot;Same&quot;:

    // Example program
    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    int main()
    {
      int a = 3;
      int b = 4;
      double d_a(a);
      double d_b(b);
      
      double int_sum = a + b;
      double d_sum = d_a + d_b;
      
      if (double(int_sum) == d_sum)
      {
          std::cout &lt;&lt; &quot;Same&quot; &lt;&lt; std::endl;
      }
    }

Is this guaranteed to be true for any architecture, any compiler, any values of `a` and `b`? Will any integer `i` converted to `double`, always be represented as `i.0000000000000` and not, for example, as `i.000000000001`?

I tried it for some other numbers and it always was true, but was unable to find anything about whether this is coincidence or by design.


Note: This is different from [this question][1] (aside from the language) since I am adding the two integers. 


  [1]: https://stackoverflow.com/questions/12629087/is-floatinteger-integer-guaranteed-to-be-equal-in-c

Are all integer values perfectly represented as doubles?

Just threw together a simple test, not for any particular reason other than I like to try to have tests for all my methods even though this one is quite straightforward, or so I thought.

        [TestMethod]
        public void Test_GetToolRating()
        {
            var rating = GetToolRating(45.5, 0);
            Assert.IsNotNull(rating);
        }
       

        private static ToolRating GetToolRating(double total, int numberOf)
        {
            var ratingNumber = 0.0;

            try
            {
                var tot = total / numberOf;
                ratingNumber = Math.Round(tot, 2);
            }
            catch (Exception ex)
            {
                var errorMessage = ex.Message;
                //log error here
                //var logger = new Logger();
                //logger.Log(errorMessage);
            }

           
            return GetToolRatingLevel(ratingNumber);
        }

As you can see in the test method, I AM dividing by zero. The problem is, it doesn&#39;t generate an error. See the error window display below.

[![Error List View from VS2017][1]][1]


  [1]: https://i.stack.imgur.com/Fjx6O.png

Instead of an error it is giving a value of infinity? What am I missing?So I googled and found that doubles divided by zero DON&#39;T generate an error they either give null or infinity. The question becomes then, how does one test for an Infinity return value?

Divide by zero and no error?

I wrote those two overloads: 
```
int func(int, int) {
	return 1;
}

int func(double, double) {
    return 2;
}
```

When I call them with the obvious two calling schemes, i.e. `func(1, 1)` and `func(1.0, 1.0)`, the first and the second overloaded functions are called, respectively, and when I try to call `func(1, 1.0)` it gives me an error, but when I cast the `1` to a `long long`, I don&#39;t get an error, and the second overload is the one called.

```
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; func(1, 1); // outputs 1.
    std::cout &lt;&lt; func(1.0, 1.0); // outputs 2.
    // std::cout &lt;&lt; func(1, 1.0); // erroneous.
    std::cout &lt;&lt; func((long long)1, 1.0); // outputs 2.
}
```

Why is this the case? At first, I thought it was because of some promotion, but I tried a third overload with two floats and I could not get it to be called by calling it like `func((int)1, 1.0f)`. I don&#39;t know why wouldn&#39;t it be the same, and I don&#39;t know why the second overload was called when a `long long` was passed.

Why is an overloaded function with two arguments of type double called when passing a long long?

I want to create a string with embedded information.  One way (not the only way) of achieving what I want is called [string interpolation][1] or variable substitution, wherein placeholders in a string are replaced with actual values.

In C, I would do something like this:

&lt;!-- language: lang-c --&gt;

    printf(&quot;error! value was %d but I expected %d&quot;,actualValue,expectedValue)

whereas if I were programming in python, I would do something like this:

&lt;!-- language: lang-python --&gt;

    &quot;error! value was {0} but I expected {1}&quot;.format(actualValue,expectedValue)

both of these are examples of string interpolation.

How can I do this in C++?

**Important Caveats**:

1. I know that I can use ``std::cout`` if I want to print such a message to standard output (not string interpolation, but prints out the kind of string I want):

&lt;!-- language: lang-c++ --&gt;

    cout &lt;&lt; &quot;error! value was &quot; &lt;&lt; actualValue &lt;&lt; &quot; but I expected &quot;
    &lt;&lt; expectedValue;

I don&#39;t want to *print* a string to stdout.  I want to pass a `std::string` as an argument to a function (e.g. the constructor of an exception object).

2. I am using C++11, but portability is potentially an issue, so knowing which methods work and don&#39;t work in which versions of C++ would be a plus.

**Edit**

3. For my immediate usage, I&#39;m not concerned about performance (I&#39;m raising an exception for cryin&#39; out loud!).  *However*, knowing the relative performance of the various methods would be very very useful in general.

4. Why not just use printf itself (C++ is a superset of C after all...)?  [This answer][2] discusses some reasons why not.  As far as I can understand, type safety is a big reason: if you put %d, the variable you put in there had better really be convertible to an integer, as that&#39;s how the function figures out what type it is.  It would be much safer to have a method which uses compile-time knowledge of the actual type of the variables to be inserted.


  [1]: https://en.wikipedia.org/wiki/String_interpolation
  [2]: https://stackoverflow.com/a/2872576/407588

How to construct a std::string with embedded values, i.e. &quot;string interpolation&quot;?

Why are **implicitly unwrapped optionals** not unwrapped when using string interpolation in Swift 3?

**Example**:
Running the following code in the playground

    var str: String!
    str = &quot;Hello&quot;
    
    print(&quot;The following should not be printed as an optional: \(str)&quot;)

produces this output: 

    The following should not be printed as an optional: Optional(&quot;Hello&quot;)

Of course I can concatenate strings with the `+` operator but I&#39;m using string interpolation pretty much everywhere in my app which now doesn&#39;t work anymore due to this (bug?). 

Is this even a bug or did they intentionally change this behaviour with Swift 3?

Swift 3 incorrect string interpolation with implicitly unwrapped Optionals

In Groovy, I have a multiline String, defined with `&#39;&#39;&#39;`, in which I need to use interpolation in order to substitute some other variables.

For all my efforts, I can&#39;t get it to work -- I assume I need to escape something, which I&#39;m missing. 

Here&#39;s some sample code:

    def cretanFood = &quot;Dakos&quot; 
    def mexicanFood = &quot;Tacos&quot;
    def bestRestaurant = &#39;&#39;&#39; 
    ${mexicanFood} &amp; ${cretanFood}
    &#39;&#39;&#39;
    print bestRestaurant


At the moment, this outputs: 

    ${mexicanFood} &amp; ${cretanFood}

while I would clearly expect: 

    Tacos &amp; Dakos 

(Note - I would prefer not to concatenate the strings)


How do I use String interpolation in a Groovy multiline string?

I have recently been learning python 3 and I cannot get any examples involving string interpolation (formatting) to work. 

    In [1]: state = &quot;Washington&quot;

    In [2]: state
    Out[2]: &#39;Washington&#39;

    In [3]: my_message = f&quot;I live in {state}&quot;
    File &quot;&lt;ipython-input-3-d004dd9e0255&gt;&quot;, line 1
    my_message = f&quot;I live in {state}&quot;
                                    ^
    SyntaxError: invalid syntax

I figured my machine was defaulting to python 2, but a quick check reveals:

    Python 3.5.2 (default, Nov 17 2016, 17:05:23) 
    Type &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.

    IPython 5.2.2 -- An enhanced Interactive Python.

I am on Ubuntu 16.04:
    
    python3 --version
    Python 3.5.2

Am I just overlooking basic syntax? I have run the same commands on a few computers from fellow students and it seems to execute just fine.



Getting an &quot;invalid syntax&quot; when trying to perform string interpolation

I am using template strings to generate some files and I love the conciseness of the new f-strings for this purpose, for reducing my previous template code from something like this:
     
    template_a = &quot;The current name is {name}&quot;
    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (template_a.format(**locals()))

Now I can do this, directly replacing variables:

    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (f&quot;The current name is {name}&quot;)

However, sometimes it makes sense to have the template defined elsewhere — higher up in the code, or imported from a file or something. This means the template is a static string with formatting tags in it. Something would have to happen to the string to tell the interpreter to interpret the string as a new f-string, but I don&#39;t know if there is such a thing.

**Is there any way to bring in a string and have it interpreted as an f-string to avoid using the `.format(**locals())` call?**

Ideally I want to be able to code like this... (where `magic_fstring_function` is where the part I don&#39;t understand comes in):

    template_a = f&quot;The current name is {name}&quot;
    # OR [Ideal2] template_a = magic_fstring_function(open(&#39;template.txt&#39;).read())
    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (template_a)

...with this desired output (without reading the file twice):

&lt;!-- language: lang-none --&gt;

    The current name is foo
    The current name is bar

...but the actual output I get is:

&lt;!-- language: lang-none --&gt;

    The current name is {name}
    The current name is {name}

How to postpone/defer the evaluation of f-strings?

I have this very simple example:

    class Program
    {
        class A
        {
            public bool B;
        }

        static void Main()
        {
            System.Collections.ArrayList list = null;

            if (list?.Count &gt; 0)
            {
                System.Console.WriteLine(&quot;Contains elements&quot;);
            }

            A a = null;

            if (a?.B)
            {
                System.Console.WriteLine(&quot;Is initialized&quot;);
            }
        }
    }

The line `if (list?.Count &gt; 0)` compiles perfectly which means that if `list` is `null`, the expression `Count &gt; 0` becomes `false` by default.

However, the line `if (a?.B)` throws a compiler error saying I can&#39;t implicitly convert `bool?` to `bool`.

Why is one different from the other?

Trying to understand ?. (null-conditional) operator in C#

In C# 6.0 the &quot;when&quot; keyword was introduced, now you&#39;re able to filter an exception in a catch block. But isn&#39;t this the same as a if statement inside a catch block? if so, isn&#39;t it just syntactic sugar or i&#39;m missing something?

For example a try catch block with the &quot;when&quot; keyword:

    try { … } 
    catch (WebException ex) when ex.Status == WebExceptionStatus.Timeout {
       //do something
    }
    catch (WebException ex) when ex.Status== WebExceptionStatus.SendFailure {
       //do something
    }
    catch (Exception caught) {…}

Or

    try { … } 
    catch (WebException ex) {
       if(ex.Status == WebExceptionStatus.Timeout) {
          //do something
       }
    }
    catch (WebException ex) {
       if(ex.Status == WebExceptionStatus.SendFailure) {
          //do something
       }
    }
    catch (Exception caught) {…}

Content Type	Original Author	Original Content on Stackoverflow
Question	MagB	View Question on Stackoverflow
Solution 1 - C#	lc.	View Answer on Stackoverflow
Solution 2 - C#	Ash Burlaczenko	View Answer on Stackoverflow

C# 6 how to format double using interpolated string?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Elm Compiler running forever, computer just getting hot

GoogleSignatureVerifier signature not valid message (google play services 9.0.0)

Attributions