Member with no value in F# - f#

I'm trying to convert the following C# code to F#:
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
private class DOCINFOA
{
[MarshalAs(UnmanagedType.LPStr)]
public string nomeDocumento;
[MarshalAs(UnmanagedType.LPStr)]
public string arquivoSaida;
[MarshalAs(UnmanagedType.LPStr)]
public string tipoDado;
}
I'm doing the following:
namespace Printer
module RawPrinterHelper =
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)>]
type DOCINFOA =
[<MarshalAs(UnmanagedType.LPStr)>]
member this.nomeDocumento
[<MarshalAs(UnmanagedType.LPStr)>]
member this.arquivoSaida
[<MarshalAs(UnmanagedType.LPStr)>]
member this.tipoDado
But I receive:
A type definition requires one or more members. Can I let these members empty?

You can use val instead of member:
[<StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)>]
type DOCINFOA =
[<MarshalAs(UnmanagedType.LPStr)>]
val nomeDocumento : string
[<MarshalAs(UnmanagedType.LPStr)>]
val arquivoSaida : string
[<MarshalAs(UnmanagedType.LPStr)>]
val tipoDado : string

Related

casting between C# derived classes, in F#

I have two types coming from a C# lib:
one is defined like this (only signatures):
public class CallResult<T>: CallResult
{
public CallResult([AllowNull]T data, Error? error): base(error)
public static implicit operator bool(CallResult<T> obj)
public bool GetResultOrError([MaybeNullWhen(false)] out T data, [NotNullWhen(false)] out Error? error)
public new static WebCallResult<T> CreateErrorResult(Error error)
}
and the second one derives from it:
public class WebCallResult<T>: CallResult<T>
{
public HttpStatusCode? ResponseStatusCode { get; set; }
public IEnumerable<KeyValuePair<string, IEnumerable<string>>>? ResponseHeaders { get; set; }
public WebCallResult(HttpStatusCode? code, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? responseHeaders, [AllowNull] T data, Error? error): base(data, error)
public WebCallResult(WebCallResult<T> callResult): base(callResult.Data, callResult.Error)
public static WebCallResult<T> CreateFrom<Y>(WebCallResult<Y> source) where Y : T
public static WebCallResult<T> CreateErrorResult(HttpStatusCode? code, IEnumerable<KeyValuePair<string, IEnumerable<string>>>? responseHeaders, Error error)
}
and they both come from:
public class CallResult
{
public Error? Error { get; internal set; }
public bool Success => Error == null;
public CallResult(Error? error)
public static implicit operator bool(CallResult obj)
public static WebCallResult CreateErrorResult(Error error)
}
Some api calls return a CallResult, others return a WebCallResult.
Right now I use two times the same code to handle it:
// turn a webcall result into a Result object
let processResultWeb (applyOnOk: 'a -> 'b) (result: WebCallResult<'a>) =
match result.Success with
| true -> Result.Ok (applyOnOk result.Data)
| false -> Result.Error (decodeError result.Error)
// turn a webcall result into a Result object
let processResult (applyOnOk: 'a -> 'b) (result: CallResult<'a>) =
match result.Success with
| true -> Result.Ok (applyOnOk result.Data)
| false -> Result.Error (decodeError result.Error)
Which doesn't really make sense since it's the same code and I'm only caring about the data from the base class (CallResult).
So I would like to cast both types to the base class:
let a: WebCallResult = ...
let r = a :> CallResult
but this results in a compiler error:
[FS0001] The type 'CallResult' is not compatible with the type 'WebCallResult<'a>'
how can I check the result for both types by just accessing the fields from their base class, but using the same generic type.
Edit:
the source code of the classes is here: https://pastebin.com/mrw5W7xk
The issue is that I want to go from:
WebCallResult<'a'> to CallResult<'a>
and the generic seems to be the issue.
Using your code, I'm able to cast with no problem, even with generics. Here's an example:
let foo x =
WebCallResult<_>(System.Nullable(), Array.empty, x, Error())
let a : WebCallResult<int> = foo 3
let r = a :> CallResult<_>
let b : WebCallResult<string> = foo "str"
let q = b :> CallResult<_>

Map generic type to record using pattern matching

I've a Union type like this:
type AccountOpenened =
{ Owner: string
AccountId: Guid
CreatedAt: DateTimeOffset
StartingBalance: decimal }
type AccountClosed = { AccountId: Guid }
type AccountEvent = AccountOpenend | AccountClosed
I also have a 3rd party library from which I can get IReadOnlyList<IEvent> whereas IEvent as this signature:
public interface IEvent {
object Data { get; }
}
The library also provides a generic class Event<T> which has this signature:
public class Event<T> : IEvent {
public T Data { get; set; }
}
What I'm trying to achieve is to map an instance of IReadOnlyList<IEvent> to an AccountEvent list using exhaustive pattern matching.
I tried something like this:
let map (input: IEvent): AccountEvent =
match input with
| :? (Event<AccountOpened>) as e ->
{ Owner = e.Data.Owner
AccountId = e.Data.AccountId
CreatedAt = e.Data.CreatedAt
StartingBalance = e.Data.StartingBalance }
| :? (Event<AccountClosed>) as e ->
{ AccountId = e.Data.AccountId }
| _ -> failwith "Unknown Event"
This doesn't work because I get this compiler error:
This expression was expected to have type 'AccountEvent' but here has type 'AccountCreation'
What am I doing wrong here?

How do I use `member val` in object expressions in fsharp?

I have an interface in F# (generated from some typescript) that looks like this:
type [<AllowNullLiteral>] AppOptions =
abstract credential: Admin.Credential.Credential option with get, set
abstract databaseAuthVariableOverride: Object option with get, set
abstract databaseURL: string option with get, set
abstract storageBucket: string option with get, set
abstract projectId: string option with get, set
I thought that the easiest way to create an instance of that type would be to create a simple object expression, but I can't get it to work. Isn't member val allowed in object expression? If not, what is the easiest way to create a simple instance of an interface with getters and setters on all properties? This is what I tried that didn't work:
let options =
{ new Admin.AppOptions with
member val credential: Admin.Credential.Credential option = None with get, set
member val databaseAuthVariableOverride: obj option = None with get, set
member val databaseURL: string option = None with get, set
member val databaseURL: string option = None with get, set
member val projectId: string option = None with get, set
}
I dont think member var is in the object expression spec only the long form properties like this are allowed:
let options =
let mutable credential = None
let mutable databaseAuthVariableOverride = None
let mutable databaseURL = None
let mutable storageBucket = None
let mutable projectId = None
{ new AppOptions with
member x.credential with get() = credential and set v = credential <- v
member x.databaseAuthVariableOverride with get() = databaseAuthVariableOverride and set v = databaseAuthVariableOverride <- v
member x.databaseURL with get() = databaseURL and set v = databaseURL <- v
member x.storageBucket with get() = storageBucket and set v = storageBucket <- v
member x.projectId with get() = projectId and set v = projectId <- v
}
Which would project C# like code by the compiler like this:
[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: AssemblyVersion("0.0.0.0")]
[CompilationMapping(SourceConstructFlags.Module)]
public static class _
{
[Serializable]
[AllowNullLiteral]
[CompilationMapping(SourceConstructFlags.ObjectType)]
public interface AppOptions
{
override FSharpOption<object> credential
{
get;
set;
}
override FSharpOption<object> databaseAuthVariableOverride
{
get;
set;
}
override FSharpOption<string> databaseURL
{
get;
set;
}
override FSharpOption<string> storageBucket
{
get;
set;
}
override FSharpOption<string> projectId
{
get;
set;
}
}
See sharplab
A normal type is probably more succinct here:
type t() =
interface AppOptions with
member val credential = None with get, set
member val databaseAuthVariableOverride = None with get, set
member val databaseURL = None with get, set
member val storageBucket = None with get, set
member val projectId = None with get, set

Listener-Parser in ANTLR4

ANTLR4 rule :
listExpr locals [Object in, Object out] : ( expr ',')* expr ;
Parser :
public static class ListExprContext extends ParserRuleContext {
public Object in;
public Object out;
public List<ExprContext> expr() {
return getRuleContexts(ExprContext.class);
}
....
}
Listener :
override def exitListExpr(ctx : BKOOLParser.ListExprContext) : Unit =
{
val listExpr = ctx.expr
val length = listExpr.length
ctx.out = length
}
I want to have the numbers of expr I have in ListExpr,but I have the error :
the result type of an implicit must be more specific than AnyRef
at line :
ctx.out = length
How to fix it ? Your help will be appreciated .

ASP MVC - Are there any constants for the default content types?

Is there a set of constants in the framework for all the standard content types?
Taking it as a resounding no, I wrote my own. That's what Sundays were made for.
///<summary>Used to denote the encoding necessary for files containing JavaScript source code. The alternative MIME type for this file type is text/javascript.</summary>
public const string ApplicationXJavascript = "application/x-javascript";
///<summary>24bit Linear PCM audio at 8-48kHz, 1-N channels; Defined in RFC 3190</summary>
public const string AudioL24 = "audio/L24";
///<summary>Adobe Flash files for example with the extension .swf</summary>
public const string ApplicationXShockwaveFlash = "application/x-shockwave-flash";
///<summary>Arbitrary binary data.[5] Generally speaking this type identifies files that are not associated with a specific application. Contrary to past assumptions by software packages such as Apache this is not a type that should be applied to unknown files. In such a case, a server or application should not indicate a content type, as it may be incorrect, but rather, should omit the type in order to allow the recipient to guess the type.[6]</summary>
public const string ApplicationOctetStream = "application/octet-stream";
///<summary>Atom feeds</summary>
public const string ApplicationAtomXml = "application/atom+xml";
///<summary>Cascading Style Sheets; Defined in RFC 2318</summary>
public const string TextCss = "text/css";
///<summary>commands; subtype resident in Gecko browsers like Firefox 3.5</summary>
public const string TextCmd = "text/cmd";
///<summary>Comma-separated values; Defined in RFC 4180</summary>
public const string TextCsv = "text/csv";
///<summary>deb (file format), a software package format used by the Debian project</summary>
public const string ApplicationXDeb = "application/x-deb";
///<summary>Defined in RFC 1847</summary>
public const string MultipartEncrypted = "multipart/encrypted";
///<summary>Defined in RFC 1847</summary>
public const string MultipartSigned = "multipart/signed";
///<summary>Defined in RFC 2616</summary>
public const string MessageHttp = "message/http";
///<summary>Defined in RFC 4735</summary>
public const string ModelExample = "model/example";
///<summary>device-independent document in DVI format</summary>
public const string ApplicationXDvi = "application/x-dvi";
///<summary>DTD files; Defined by RFC 3023</summary>
public const string ApplicationXmlDtd = "application/xml-dtd";
///<summary>ECMAScript/JavaScript; Defined in RFC 4329 (equivalent to application/ecmascript but with looser processing rules) It is not accepted in IE 8 or earlier - text/javascript is accepted but it is defined as obsolete in RFC 4329. The "type" attribute of the <script> tag in HTML5 is optional and in practice omitting the media type of JavaScript programs is the most interoperable solution since all browsers have always assumed the correct default even before HTML5.</summary>
public const string ApplicationJavascript = "application/javascript";
///<summary>ECMAScript/JavaScript; Defined in RFC 4329 (equivalent to application/javascript but with stricter processing rules)</summary>
public const string ApplicationEcmascript = "application/ecmascript";
///<summary>EDI EDIFACT data; Defined in RFC 1767</summary>
public const string ApplicationEdifact = "application/EDIFACT";
///<summary>EDI X12 data; Defined in RFC 1767</summary>
public const string ApplicationEdiX12 = "application/EDI-X12";
///<summary>Email; Defined in RFC 2045 and RFC 2046</summary>
public const string MessagePartial = "message/partial";
///<summary>Email; EML files, MIME files, MHT files, MHTML files; Defined in RFC 2045 and RFC 2046</summary>
public const string MessageRfc822 = "message/rfc822";
///<summary>Extensible Markup Language; Defined in RFC 3023</summary>
public const string TextXml = "text/xml";
///<summary>Extensible Markup Language; Defined in RFC 3023</summary>
public const string ApplicationXml = "application/xml";
///<summary>Flash video (FLV files)</summary>
public const string VideoXFlv = "video/x-flv";
///<summary>GIF image; Defined in RFC 2045 and RFC 2046</summary>
public const string ImageGif = "image/gif";
///<summary>GoogleWebToolkit data</summary>
public const string TextXGwtRpc = "text/x-gwt-rpc";
///<summary>Gzip</summary>
public const string ApplicationXGzip = "application/x-gzip";
///<summary>HTML; Defined in RFC 2854</summary>
public const string TextHtml = "text/html";
///<summary>ICO image; Registered[9]</summary>
public const string ImageVndMicrosoftIcon = "image/vnd.microsoft.icon";
///<summary>IGS files, IGES files; Defined in RFC 2077</summary>
public const string ModelIges = "model/iges";
///<summary>IMDN Instant Message Disposition Notification; Defined in RFC 5438</summary>
public const string MessageImdnXml = "message/imdn+xml";
///<summary>JavaScript Object Notation JSON; Defined in RFC 4627</summary>
public const string ApplicationJson = "application/json";
///<summary>JavaScript Object Notation (JSON) Patch; Defined in RFC 6902</summary>
public const string ApplicationJsonPatch = "application/json-patch+json";
///<summary>JavaScript - Defined in and obsoleted by RFC 4329 in order to discourage its usage in favor of application/javascript. However,text/javascript is allowed in HTML 4 and 5 and, unlike application/javascript, has cross-browser support. The "type" attribute of the <script> tag in HTML5 is optional and there is no need to use it at all since all browsers have always assumed the correct default (even in HTML 4 where it was required by the specification).</summary>
[Obsolete]
public const string TextJavascript = "text/javascript";
///<summary>JPEG JFIF image; Associated with Internet Explorer; Listed in ms775147(v=vs.85) - Progressive JPEG, initiated before global browser support for progressive JPEGs (Microsoft and Firefox).</summary>
public const string ImagePjpeg = "image/pjpeg";
///<summary>JPEG JFIF image; Defined in RFC 2045 and RFC 2046</summary>
public const string ImageJpeg = "image/jpeg";
///<summary>jQuery template data</summary>
public const string TextXJqueryTmpl = "text/x-jquery-tmpl";
///<summary>KML files (e.g. for Google Earth)</summary>
public const string ApplicationVndGoogleEarthKmlXml = "application/vnd.google-earth.kml+xml";
///<summary>LaTeX files</summary>
public const string ApplicationXLatex = "application/x-latex";
///<summary>Matroska open media format</summary>
public const string VideoXMatroska = "video/x-matroska";
///<summary>Microsoft Excel 2007 files</summary>
public const string ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
///<summary>Microsoft Excel files</summary>
public const string ApplicationVndMsExcel = "application/vnd.ms-excel";
///<summary>Microsoft Powerpoint 2007 files</summary>
public const string ApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
///<summary>Microsoft Powerpoint files</summary>
public const string ApplicationVndMsPowerpoint = "application/vnd.ms-powerpoint";
///<summary>Microsoft Word 2007 files</summary>
public const string ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
///<summary>Microsoft Word files[15]</summary>
public const string ApplicationMsword = "application/msword";
///<summary>MIME Email; Defined in RFC 2045 and RFC 2046</summary>
public const string MultipartAlternative = "multipart/alternative";
///<summary>MIME Email; Defined in RFC 2045 and RFC 2046</summary>
public const string MultipartMixed = "multipart/mixed";
///<summary>MIME Email; Defined in RFC 2387 and used by MHTML (HTML mail)</summary>
public const string MultipartRelated = "multipart/related";
///<summary>MIME Webform; Defined in RFC 2388</summary>
public const string MultipartFormData = "multipart/form-data";
/// <summary>Body contains a URL-encoded query string as per RFC 1867</summary>
public const string ApplicationWwwFormUrlEncoded = "application/x-www-form-urlencoded";
///<summary>Mozilla XUL files</summary>
public const string ApplicationVndMozillaXulXml = "application/vnd.mozilla.xul+xml";
///<summary>MP3 or other MPEG audio; Defined in RFC 3003</summary>
public const string AudioMpeg = "audio/mpeg";
///<summary>MP4 audio</summary>
public const string AudioMp4 = "audio/mp4";
///<summary>MP4 video; Defined in RFC 4337</summary>
public const string VideoMp4 = "video/mp4";
///<summary>MPEG-1 video with multiplexed audio; Defined in RFC 2045 and RFC 2046</summary>
public const string VideoMpeg = "video/mpeg";
///<summary>MSH files, MESH files; Defined in RFC 2077, SILO files</summary>
public const string ModelMesh = "model/mesh";
///<summary>mulaw audio at 8 kHz, 1 channel; Defined in RFC 2046</summary>
public const string AudioBasic = "audio/basic";
///<summary>Ogg Theora or other video (with audio); Defined in RFC 5334</summary>
public const string VideoOgg = "video/ogg";
///<summary>Ogg Vorbis, Speex, Flac and other audio; Defined in RFC 5334</summary>
public const string AudioOgg = "audio/ogg";
///<summary>Ogg, a multimedia bitstream container format; Defined in RFC 5334</summary>
public const string ApplicationOgg = "application/ogg";
///<summary>OP</summary>
public const string ApplicationXopXml = "application/xop+xml";
///<summary>OpenDocument Graphics; Registered[14]</summary>
public const string ApplicationVndOasisOpendocumentGraphics = "application/vnd.oasis.opendocument.graphics";
///<summary>OpenDocument Presentation; Registered[13]</summary>
public const string ApplicationVndOasisOpendocumentPresentation = "application/vnd.oasis.opendocument.presentation";
///<summary>OpenDocument Spreadsheet; Registered[12]</summary>
public const string ApplicationVndOasisOpendocumentSpreadsheet = "application/vnd.oasis.opendocument.spreadsheet";
///<summary>OpenDocument Text; Registered[11]</summary>
public const string ApplicationVndOasisOpendocumentText = "application/vnd.oasis.opendocument.text";
///<summary>p12 files</summary>
public const string ApplicationXPkcs12 = "application/x-pkcs12";
///<summary>p7b and spc files</summary>
public const string ApplicationXPkcs7Certificates = "application/x-pkcs7-certificates";
///<summary>p7c files</summary>
public const string ApplicationXPkcs7Mime = "application/x-pkcs7-mime";
///<summary>p7r files</summary>
public const string ApplicationXPkcs7Certreqresp = "application/x-pkcs7-certreqresp";
///<summary>p7s files</summary>
public const string ApplicationXPkcs7Signature = "application/x-pkcs7-signature";
///<summary>Portable Document Format, PDF has been in use for document exchange on the Internet since 1993; Defined in RFC 3778</summary>
public const string ApplicationPdf = "application/pdf";
///<summary>Portable Network Graphics; Registered,[8] Defined in RFC 2083</summary>
public const string ImagePng = "image/png";
///<summary>PostScript; Defined in RFC 2046</summary>
public const string ApplicationPostscript = "application/postscript";
///<summary>QuickTime video; Registered[10]</summary>
public const string VideoQuicktime = "video/quicktime";
///<summary>RAR archive files</summary>
public const string ApplicationXRarCompressed = "application/x-rar-compressed";
///<summary>RealAudio; Documented in RealPlayer Customer Support Answer 2559</summary>
public const string AudioVndRnRealaudio = "audio/vnd.rn-realaudio";
///<summary>Resource Description Framework; Defined by RFC 3870</summary>
public const string ApplicationRdfXml = "application/rdf+xml";
///<summary>RSS feeds</summary>
public const string ApplicationRssXml = "application/rss+xml";
///<summary>SOAP; Defined by RFC 3902</summary>
public const string ApplicationSoapXml = "application/soap+xml";
///<summary>StuffIt archive files</summary>
public const string ApplicationXStuffit = "application/x-stuffit";
///<summary>SVG vector image; Defined in SVG Tiny 1.2 Specification Appendix M</summary>
public const string ImageSvgXml = "image/svg+xml";
///<summary>Tag Image File Format (only for Baseline TIFF); Defined in RFC 3302</summary>
public const string ImageTiff = "image/tiff";
///<summary>Tarball files</summary>
public const string ApplicationXTar = "application/x-tar";
///<summary>Textual data; Defined in RFC 2046 and RFC 3676</summary>
public const string TextPlain = "text/plain";
///<summary>TrueType Font No registered MIME type, but this is the most commonly used</summary>
public const string ApplicationXFontTtf = "application/x-font-ttf";
///<summary>vCard (contact information); Defined in RFC 6350</summary>
public const string TextVcard = "text/vcard";
///<summary>Vorbis encoded audio; Defined in RFC 5215</summary>
public const string AudioVorbis = "audio/vorbis";
///<summary>WAV audio; Defined in RFC 2361</summary>
public const string AudioVndWave = "audio/vnd.wave";
///<summary>Web Open Font Format; (candidate recommendation; use application/x-font-woff until standard is official)</summary>
public const string ApplicationFontWoff = "application/font-woff";
///<summary>WebM Matroska-based open media format</summary>
public const string VideoWebm = "video/webm";
///<summary>WebM open media format</summary>
public const string AudioWebm = "audio/webm";
///<summary>Windows Media Audio Redirector; Documented in Microsoft help page</summary>
public const string AudioXMsWax = "audio/x-ms-wax";
///<summary>Windows Media Audio; Documented in Microsoft KB 288102</summary>
public const string AudioXMsWma = "audio/x-ms-wma";
///<summary>Windows Media Video; Documented in Microsoft KB 288102</summary>
public const string VideoXMsWmv = "video/x-ms-wmv";
///<summary>WRL files, VRML files; Defined in RFC 2077</summary>
public const string ModelVrml = "model/vrml";
///<summary>X3D ISO standard for representing 3D computer graphics, X3D XML files</summary>
public const string ModelX3DXml = "model/x3d+xml";
///<summary>X3D ISO standard for representing 3D computer graphics, X3DB binary files</summary>
public const string ModelX3DBinary = "model/x3d+binary";
///<summary>X3D ISO standard for representing 3D computer graphics, X3DV VRML files</summary>
public const string ModelX3DVrml = "model/x3d+vrml";
///<summary>XHTML; Defined by RFC 3236</summary>
public const string ApplicationXhtmlXml = "application/xhtml+xml";
///<summary>ZIP archive files; Registered[7]</summary>
public const string ApplicationZip = "application/zip";
Update
Stumbled upon this great resource today.
https://www.iana.org/assignments/media-types/media-types.xhtml
Update 22-03-2020
As Jon and James White mentioned on comments, you can check:
System.Net.Mime.MediaTypeNames
You could use:
System.Net.Mime.MediaTypeNames.Application
System.Net.Mime.MediaTypeNames.Image
System.Net.Mime.MediaTypeNames.Text
For example, System.Net.Mime.MediaTypeNames.Image.Gif is equal to "image/gif".
Here is the complete list of default content type constants in .NET Framework base class library (BCL). You will have to add reference to System.Net.Http.dll in your project to use these constants.
System.Net.Mime.MediaTypeNames.Application.Octet for application/octet-stream
System.Net.Mime.MediaTypeNames.Application.Pdf for application/pdf
System.Net.Mime.MediaTypeNames.Application.Rtf for application/rtf
System.Net.Mime.MediaTypeNames.Application.Soap for application/soap+xml
System.Net.Mime.MediaTypeNames.Application.Zip for application/zip
System.Net.Mime.MediaTypeNames.Image.Gif for image/gif
System.Net.Mime.MediaTypeNames.Image.Jpeg for image/jpeg
System.Net.Mime.MediaTypeNames.Image.Tiff for image/tiff
System.Net.Mime.MediaTypeNames.Text.Html for text/html
System.Net.Mime.MediaTypeNames.Text.Plain for text/plain
System.Net.Mime.MediaTypeNames.Text.RichText for text/richtext
System.Net.Mime.MediaTypeNames.Text.Xml for text/xml
Update[12-Aug-2021]:
A new set of constants are now available in System.Net.Mime namespace. This namespace is part of System.Net.Mail.dll which is referenced by default whenever you create a new project targeting .NET v5. This DLL is part of .NET v5 (erstwhile .NET Core v5) release.
MediaTypeNames.Application.Json
MediaTypeNames.Application.Octet
MediaTypeNames.Application.Pdf
MediaTypeNames.Application.Rtf
MediaTypeNames.Application.Soap
MediaTypeNames.Application.Xml
MediaTypeNames.Application.Zip
MediaTypeNames.Image.Gif
MediaTypeNames.Image.Jpeg
MediaTypeNames.Image.Tiff
MediaTypeNames.Text.Html
MediaTypeNames.Text.Plain
MediaTypeNames.Text.RichText
MediaTypeNames.Text.Xml
Note: .NET v5 is not a new release of .NET Framework. Instead it is the next major release of .NET following .NET Core v3.1. .NET is new name of .NET Core. Core branding has been removed.
In the new ASP.NET Core MimeMapping can be used with the filename:
MimeMapping.GetMimeMapping("1.jpg")
Should return image/jpeg.
All the mappings can be found here and it is also possible to add your own (see e.g. this answer).
Here's the official on going list if interested
http://www.iana.org/assignments/media-types/media-types.xhtml
Please also check this amazing solution in below link (section "Using a static MIME Type Map"):
https://www.ryadel.com/en/get-file-content-mime-type-from-extension-asp-net-mvc-core/
You can simply use it like that:
var mineType=
MimeTypeMap.GetMimeType(System.IO.Path.GetExtension(submitted));
https://www.nuget.org/packages/MimeTypesMap/ is a great NuGet package for this. Use it like this:
MimeTypesMap.GetMimeType("filename.jpeg"); // => image/jpeg
or the other way:
MimeTypesMap.GetExtension("image/jpeg"); // => jpeg

Resources