Updated. As of C# 10, you can define either a struct or class-based record to fulfill this requirement:

    public record struct ResponseKey(Guid venueId, string contentId, string answer);
    public record class ResponseKey(Guid venueId, string contentId, string answer);

Note that `class` is optional for the second definition.

----
[This has been requested, and recorded in the Roslyn repo on Github][1]. However it received a mixed reception there, and [the proposed record types][2], would more than cover this requirement.

The issue was closed in the Roslyn repo [but is now being tracked in the C# language repo][3].

  [1]: https://github.com/dotnet/roslyn/issues/15072
  [2]: https://github.com/dotnet/csharplang/issues/39
  [3]: https://github.com/dotnet/csharplang/issues/423

npm package `@types/react` allows us to use React inside of our TypeScript apps.
We define components as

    type Props = {...}

    type State = {...}

    export default class MyComponent extends React.Component&lt;Props, State&gt; {
    }

here we have to declare types for component props and state (in type variables).

After we declared that types, TypeScript uses that to validate the usage of our component (the shape of props passed to it).

I want to create a container around such a component. The container will reuse the props of the component. But in order to create another component with the same props I have to redeclare the types for props again. Or export them from the original component file and import into container:

    // original file
    export type Props = {...}

    // container file
    import MyComponent, { Props } from &#39;./original&#39;

But I&#39;m already importing the `MyComponent` from that file. This component already contains information about the props it consumes (thanks to type variables in `React.Component`).

The question is **how do I access that information from the component class itself without explicitly exporting/importing the type for props**?

I want something like:

    import MyComponent from &#39;./MyComponent&#39;

    type Props = MyComponent.Props // &lt;= here access the component prop types

    export default class MyContainer extends React.Component&lt;Props, {}&gt; {}



Typescript React: Access component property types

[Cloud Functions][1] and [Firebase Functions (or &quot;Cloud Functions for Firebase&quot;)][2] both look the same. Please describe the use case of each. 

Both use HTTP functions.

&lt;!-- language-all: lang-js --&gt;

In the **Cloud Functions**:

    exports.helloHttp = function helloHttp (req, res) {
      res.send(`Hello ${req.body.name || &#39;World&#39;}!`);
    };

And in the **Firebase Functions**:

    exports.helloWorld = functions.https.onRequest((request, response) =&gt; {
      response.send(&quot;Hello from Firebase!&quot;);
    });

What is difference between these?


  [1]: https://cloud.google.com/functions/
  [2]: https://firebase.google.com/docs/functions/

What is the difference between Cloud Functions and Firebase Functions?

I know it&#39;s possible to define aliases in C# with the *using* keyword.

e.g.

    using ResponseKey = System.ValueTuple&lt;System.Guid, string, string&gt;;

However, is it possible to define one using the new syntax for value tuples?

    using ResponseKey = (Guid venueId, string contentId, string answer);

This syntax does not appear to work. Should it?


In C# can you define an alias to a value tuple with names?

I know it's possible to define aliases in C# with the using keyword.
e.g.
<pre><code class="hljs language-csharp">using ResponseKey = System.ValueTuple&#x3C;System.Guid, string, string>;
</code></pre>
However, is it possible to define one using the new syntax for value tuples?
<pre><code class="hljs language-csharp">using ResponseKey = (Guid venueId, string contentId, string answer);
</code></pre>
This syntax does not appear to work. Should it?

This question is very similar to https://stackoverflow.com/questions/36057041/setting-the-version-number-for-net-core-projects, but not the same. Using the latest stable version of .NET Core at the time of writing (1.1) and VS2017, .NET Core has switched from JSON based project files to CSPROJ files.

So - what I am trying to do is set up a CI environment where I would like to be able to modify *something* prior to a build to stamp my builds with the correct version number.

If I use the attributes like this the old (SharedAssemblyInfo.cs trick):

&lt;!-- language: c# --&gt;

    [assembly: AssemblyFileVersion(&quot;3.3.3.3&quot;)]
    [assembly: AssemblyVersion(&quot;4.4.4.4&quot;)]

somewhere in the project, I get   
`CS0579 - Duplicate &#39;System.Reflection.AssemblyFileVersionAttribute&#39;`  
and  
`CS0579 - Duplicate &#39;System.Reflection.AssemblyVersionAttribute&#39;`  
errors when building.

When digging into it a bit, I find that there is a file which looks like this generated during the build process (it doesn&#39;t exist before I build) in `\obj\Debug\netcoreapp1.1`:


&lt;!-- language: c# --&gt;

    //------------------------------------------------------------------------------
    // &lt;auto-generated&gt;
    //     This code was generated by a tool.
    //     Runtime Version:4.0.30319.42000
    //
    //     Changes to this file may cause incorrect behavior and will be lost if
    //     the code is regenerated.
    // &lt;/auto-generated&gt;
    //------------------------------------------------------------------------------

    using System;
    using System.Reflection;

    [assembly: System.Reflection.AssemblyCompanyAttribute(&quot;TestApplication&quot;)]
    [assembly: System.Reflection.AssemblyConfigurationAttribute(&quot;Debug&quot;)]
    [assembly: System.Reflection.AssemblyDescriptionAttribute(&quot;Package Description&quot;)]
    [assembly: System.Reflection.AssemblyFileVersionAttribute(&quot;1.1.99.0&quot;)]
    [assembly: System.Reflection.AssemblyInformationalVersionAttribute(&quot;1.1.99&quot;)]
    [assembly: System.Reflection.AssemblyProductAttribute(&quot;TestApplication&quot;)]
    [assembly: System.Reflection.AssemblyTitleAttribute(&quot;TestApplication&quot;)]
    [assembly: System.Reflection.AssemblyVersionAttribute(&quot;1.1.99.0&quot;)]

    // Generated by the MSBuild WriteCodeFragment class.

**Question - How do I do this bit?**  
So I can see that this must somehow be generated from the values entered in the project properties &#39;package page&#39;, but I don&#39;t know what the right way would be to change these values on my CI machine.

Ideally, I&#39;d like to be able to specify all this information in my (Jenkins) CI script, but I&#39;d settle for just being able to set the version number.

**EDIT - More Info**  
After reading the first answer, I wanted to make it clear that I am creating both services and NuGET packages - and I would prefer to have 1 way of versioning everything, which would be like the old JSON project where I could just update a single file.  

**UPDATE**
I am going with scripting a change to the CSPROJ file which in my opinion is rather hacky as the section I need to modify looks like this...


&lt;!-- language: xml --&gt;

    &lt;PropertyGroup&gt;
     &lt;OutputType&gt;Exe&lt;/OutputType&gt;
     &lt;TargetFramework&gt;netcoreapp1.1&lt;/TargetFramework&gt;
     &lt;Version&gt;1.0.7777.0&lt;/Version&gt;
     &lt;AssemblyVersion&gt;1.0.8888.0&lt;/AssemblyVersion&gt;
     &lt;FileVersion&gt;1.0.9999.0&lt;/FileVersion&gt;
     &lt;Company&gt;MyCompany&lt;/Company&gt;
     &lt;Authors&gt;AuthorName&lt;/Authors&gt;
     &lt;Product&gt;ProductName&lt;/Product&gt;
     &lt;Description /&gt;
     &lt;Copyright&gt;Copyright &#169; 2017&lt;/Copyright&gt;
    &lt;/PropertyGroup&gt;

So - the problem here is that there are multiple &#39;PropertyGroup&#39; elements; the others appear to be labelled - but not knowing how the CSPROJ is put together, I can&#39;t say this will always be the case.  

I am working on the premise that the package details will always be filled in, otherwise the value tags (above) don&#39;t appear in the XML - so then I can use a script to update the values in place. If the value tags were not there, I would have no clear idea which PropertyGroup element to insert the values into (and also which order, as this appears to be important; changing the order stopped me from loading the project in VS2017). 

I am still holding out for a better solution than this one!

Update: After someone marking this question as a possible duplicate (https://stackoverflow.com/questions/43019832/auto-versioning-in-visual-studio-2017-net-core) - I hadn&#39;t seen this question before and now reading it seems to be almost the same except that I dont just want to set the version number. Also, the answers to this question do not solve my problem - only asks what I asked in my question. The accepted answer to my question is exactly the answer I need to solve my problem - so while the other question came first and appears the same - it does not help me at all. Maybe a mod can help?

Setting the version number for .NET Core projects - CSPROJ - not JSON projects

I want to set the precision of all the decimal properties to (18,6). In EF6 this was quite easy:

    modelBuilder.Properties&lt;decimal&gt;().Configure(x =&gt; x.HasPrecision(18, 6));

but I can&#39;t seem to find anything similar to this in EF Core. Removing the cascade delete convention wasn&#39;t as simple as in EF6 so I found the following workaround:

EF6:
  
    modelBuilder.Conventions.Remove&lt;ManyToManyCascadeDeleteConvention&gt;();
    modelBuilder.Conventions.Remove&lt;OneToManyCascadeDeleteConvention&gt;();

EF Core:
    
    foreach (var relationship in modelBuilder.Model.GetEntityTypes().SelectMany(e =&gt; e.GetForeignKeys()))
        relationship.DeleteBehavior = DeleteBehavior.Restrict;

and after I read [this](https://stackoverflow.com/questions/30388695/entity-framework-7-set-decimal-precision-for-model-builder), I tried a similar approach:

    foreach (var entityType in modelBuilder.Model.GetEntityTypes()
        .SelectMany(x =&gt; x.GetProperties())
        .Where(x =&gt; x.ClrType == typeof(decimal)))
            {
                // what to do here?
            }

I would like if I am on the right track and how to continue, or if not, should I start putting data annotations on all the `decimal` properties.



Entity Framework Core - setting the decimal precision and scale to all decimal properties

&quot;Contains&quot; in Entity Framework core should equivalent to the SQL %like% operator. Therefore &quot;Contains&quot; should be case insensitive however it is case sensitive! (at least in postgres????)

The following only outputs a result when the correct casing for keyword is used.

    context.Counties.Where(x =&gt; x.Name.Contains(keyword)).ToList();

What am I doing wrong?


Entity Framework core - Contains is case sensitive or case insensitive?

Creating Dependency Injection with ASP.NET Core is fairly easy. The documentation explains it very well [here][1] and this guy has a [killer video][2] to explain it.


However, I want to do the same thing with my ASP.NET MVC 5 project. How can handle dependency injection with ASP.MVC 5?

Also, is Dependency injection limited to controllers only or can it work with any class?

  [1]: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?highlight=dependency#registering-your-own-services
  [2]: https://www.youtube.com/watch?v=5A2UxMGA58g

How to create dependency injection for ASP.NET MVC 5?

When I try running the command &quot;update-database&quot;, I get this exception:

&gt; Specify the &#39;-Verbose&#39; flag to view the SQL statements being applied
&gt; to the target database.     System.IO.FileNotFoundException: Could not
&gt; load file or assembly &#39;Microsoft.Build.Framework, Version=15.1.0.0,
&gt; Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a&#39; or one of its
&gt; dependencies. The system cannot find the file specified. File name:
&gt; &#39;Microsoft.Build.Framework, Version=15.1.0.0, Culture=neutral,
&gt; PublicKeyToken=b03f5f7f11d50a3a&#39;    
&gt; 
&gt; WRN: Assembly binding logging is turned OFF. To enable assembly bind
&gt; failure logging, set the registry value
&gt; [HKLM\Software\Microsoft\Fusion!EnableLog] (DWORD) to 1. Note: There
&gt; is some performance penalty associated with assembly bind failure
&gt; logging. To turn this feature off, remove the registry value
&gt; [HKLM\Software\Microsoft\Fusion!EnableLog].
&gt; 
&gt; Could not load file or assembly &#39;Microsoft.Build.Framework,
&gt; Version=15.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a&#39; or
&gt; one of its dependencies. The system cannot find the file specified.`

Could not load file or assembly &#39;Microsoft.Build.Framework&#39;(VS 2017)

Given:

    class Program
    {
        private static readonly List&lt;(int a, int b, int c)&gt; Map = new List&lt;(int a, int b, int c)&gt;()
        {
            (1, 1, 2),
            (1, 2, 3),
            (2, 2, 4)
        };

        static void Main(string[] args)
        {
            var result = Map.FirstOrDefault(w =&gt; w.a == 4 &amp;&amp; w.b == 4);

            if (result == null)
                Console.WriteLine(&quot;Not found&quot;);
            else
                Console.WriteLine(&quot;Found&quot;);
        }
    }

In the above example, a compiler error is encountered at line `if (result == null)`.  

&gt; CS0019	Operator &#39;==&#39; cannot be applied to operands of type &#39;(int a, int b, int c)&#39; and &#39;\&lt;null\&gt;&#39;

How would I go about checking that the tuple is found prior to proceeding in my &quot;found&quot; logic?

Prior to using the new c# 7 tuples, I would have this:

    class Program
    {
        private static readonly List&lt;Tuple&lt;int, int, int&gt;&gt; Map = new List&lt;Tuple&lt;int, int, int&gt;&gt;()
        {
            new Tuple&lt;int, int, int&gt; (1, 1, 2),
            new Tuple&lt;int, int, int&gt; (1, 2, 3),
            new Tuple&lt;int, int, int&gt; (2, 2, 4)
        };

        static void Main(string[] args)
        {
            var result = Map.FirstOrDefault(w =&gt; w.Item1 == 4 &amp;&amp; w.Item2 == 4);

            if (result == null)
                Console.WriteLine(&quot;Not found&quot;);
            else
                Console.WriteLine(&quot;Found&quot;);
        }
    }

Which worked fine.  I like the more easily interpreted intention of the new syntax, but am unsure on how to null check it prior to acting on what was found (or not).

How to null check c# 7 tuple in LINQ query?

Given the following code:

    string someString = null;
    switch (someString)
    {
        case string s:
            Console.WriteLine(&quot;string s&quot;);
            break;
        case var o:
            Console.WriteLine(&quot;var o&quot;);
            break;
        default:
            Console.WriteLine(&quot;default&quot;);
            break;
    }

Why is the switch statement matching on `case var o`?

It is my understanding that `case string s` does not match when `s == null` because (effectively) `(null as string) != null` evaluates to false. IntelliSense on VS Code tells me that `o` is a `string` as well. Any thoughts?

---

Similiar to: https://stackoverflow.com/questions/42950833/c-sharp-7-switch-case-with-null-checks

switch with var/null strange behavior

Before Tuples, I used to create a class and its variables, then create object from this class and make that object the return type for some functions. 

Now, with tuples, I can do the same thing, and in C# 7.0 we can assign understandable names for tuple properties (before this, it was `item1`, `item2`, etc..)

So now I am wondering, when do I use tuple and when do I create a class in C# 7.0?

When to use: Tuple vs Class in C# 7.0

I know this may sound strange but I don&#39;t know even how to search this syntax in internet and also I am not sure what exactly means.

So I&#39;ve watched over some MoreLINQ code and then I noticed this method

    public static IEnumerable&lt;TSource&gt; DistinctBy&lt;TSource, TKey&gt;(this IEnumerable&lt;TSource&gt; source,
            Func&lt;TSource, TKey&gt; keySelector, IEqualityComparer&lt;TKey&gt; comparer)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));
           
        return _(); IEnumerable&lt;TSource&gt; _()
        {
            var knownKeys = new HashSet&lt;TKey&gt;(comparer);
            foreach (var element in source)
            {
                if (knownKeys.Add(keySelector(element)))
                    yield return element;
            }
        }
    }

What is this odd return statement? `return _();` ?

Odd return syntax statement

In JavaScript ES6, you are able to destructure arrays like this:

    const [a,b,...rest] = someArray;

where `a` is the first element in the array, `b` is the second, and `rest` is an array with the remaining elements.

I know in C#7 that you can destructure tuples during assignment, but could not find anything related to destructuring arrays/enumerables like this:

    var (a,b) = someTuple;

I have an `IEnumerable` where I need the first and second elements as variables, and I need the rest of the elements as another IEnumerable. I have a solution, but feel that destructuring will look cleaner.


Content Type	Original Author	Original Content on Stackoverflow
Question	Nick Randell	View Question on Stackoverflow
Solution 1 - C#	David Arno	View Answer on Stackoverflow

In C# can you define an alias to a value tuple with names?

C# Problem Overview

C# Solutions

Solution 1 - C#

What is the difference between Cloud Functions and Firebase Functions?

Typescript React: Access component property types

Attributions