const express = require('express')
const app = express()
const PORT = 3000;
app.get('/', (req, res) => {
res.send('Hello World')
})
app.listen(PORT, () => {
console.log(`listening on port ${PORT}!`)
}) "scripts": {
"start": "node index"
}, FROM node ENV NODE_ENV=production COPY . /var/www WORKDIR /var/www RUN npm i EXPOSE 3000 ENTRYPOINT npm start
docker build -f Dockerfile -t alikhll/testnode1 .
docker run -d -p 8080:3000 alikhll/testnode1
dotnet new web dotnet restore dotnet run
FROM microsoft/dotnet ENV ASPNETCORE_URLS http://*:3000 COPY . /var/www WORKDIR /var/www RUN dotnet restore EXPOSE 3000 ENTRYPOINT dotnet run
docker build -f Dockerfile -t alikhll/testasp1 .
docker run -d -p 8080:3000 alikhll/testasp1
docker login
docker push alikhll/testnode1
docker pull alikhll/testnode1
اگر compatibility level بانک اطلاعاتی شما 90 یا بیشتر باشد، بله.
Garbage Collection
string message = "Hello World!";
#include <stdio.h>
#include <stdlib.h>
void printReport(int* data)
{
printf("Report: %d", *data);
}
int main(void)
{
int *myNumber;
myNumber = (int*)malloc(sizeof(int));
if (myNumber == 0)
{
printf("ERROR: Out of memory");
return 1;
}
*myNumber = 25;
printReport(myNumber);
free(myNumber);
myNumber = NULL;
return 0;
} using System;
public class Program
{
public static void Main()
{
int myNumber = 25;
PrintReport(myNumber);
}
private static void PrintReport(int number)
{
Console.WriteLine($"Report: {number}");
}
} 
<PropertyGroup>
<TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
<TargetPlatformVersion>8.1</TargetPlatformVersion>
</PropertyGroup> <ItemGroup>
<Reference Include="System" />
<Reference Include="System.ComponentModel.DataAnnotations" />
<Reference Include="System.Core" />
<Reference Include="System.ObjectModel" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
<Reference Include="System.Threading" />
<Reference Include="System.Threading.Tasks" />
</ItemGroup>
<ItemGroup>
<Reference Include="Windows" />
<Reference Include="System.Runtime" />
<Reference Include="System.Runtime.WindowsRuntime" />
</ItemGroup> install-package Nito.AsyncEx
using System;
using System.IO;
using Windows.Storage.Streams;
namespace ConsoleWin81PdfApiTest
{
public static class MicrosoftStreamExtensions
{
public static IRandomAccessStream AsRandomAccessStream(this Stream stream)
{
return new RandomStream(stream);
}
}
class RandomStream : IRandomAccessStream
{
readonly Stream _internstream;
public RandomStream(Stream underlyingstream)
{
_internstream = underlyingstream;
}
public IInputStream GetInputStreamAt(ulong position)
{
_internstream.Position = (long)position;
return _internstream.AsInputStream();
}
public IOutputStream GetOutputStreamAt(ulong position)
{
_internstream.Position = (long)position;
return _internstream.AsOutputStream();
}
public ulong Size
{
get
{
return (ulong)_internstream.Length;
}
set
{
_internstream.SetLength((long)value);
}
}
public bool CanRead
{
get { return _internstream.CanRead; }
}
public bool CanWrite
{
get { return _internstream.CanWrite; }
}
public IRandomAccessStream CloneStream()
{
throw new NotSupportedException();
}
public ulong Position
{
get { return (ulong)_internstream.Position; }
}
public void Seek(ulong position)
{
_internstream.Seek((long)position, SeekOrigin.Begin);
}
public void Dispose()
{
_internstream.Dispose();
}
public Windows.Foundation.IAsyncOperationWithProgress<IBuffer, uint> ReadAsync(IBuffer buffer, uint count, InputStreamOptions options)
{
return GetInputStreamAt(Position).ReadAsync(buffer, count, options);
}
public Windows.Foundation.IAsyncOperation<bool> FlushAsync()
{
return GetOutputStreamAt(Position).FlushAsync();
}
public Windows.Foundation.IAsyncOperationWithProgress<uint, uint> WriteAsync(IBuffer buffer)
{
return GetOutputStreamAt(Position).WriteAsync(buffer);
}
}
} using System;
using System.IO;
using System.Threading.Tasks;
using Windows.Data.Pdf;
using Nito.AsyncEx;
namespace ConsoleWin81PdfApiTest
{
class Program
{
static void Main(string[] args)
{
AsyncContext.Run(async () =>
{
await test();
});
}
private static async Task test()
{
using (var randomAccessStream = File.Open("PieChartPdfReport.pdf", FileMode.Open).AsRandomAccessStream())
{
var pdfDocument = await PdfDocument.LoadFromStreamAsync(randomAccessStream);
for (uint i = 0; i < pdfDocument.PageCount; i++)
{
using (var page = pdfDocument.GetPage(i))
{
/*var renderOptions = new PdfPageRenderOptions
{
BackgroundColor = Colors.LightGray,
DestinationHeight = (uint) (page.Size.Height*10)
};*/
using (var stream = File.Open(string.Format("page-{0}.png", i + 1), FileMode.OpenOrCreate).AsRandomAccessStream())
{
await page.RenderToStreamAsync(stream/*, renderOptions*/);
await stream.FlushAsync();
}
}
}
}
}
}
} 
[DllImport("kernel32.dll")]
public static extern void GetSystemInfo([MarshalAs(UnmanagedType.Struct)] ref SYSTEM_INFO lpSystemInfo);
[StructLayout(LayoutKind.Sequential)]
public struct SYSTEM_INFO
{
internal _PROCESSOR_INFO_UNION uProcessorInfo;
public uint dwPageSize;
public IntPtr lpMinimumApplicationAddress;
public int lpMaximumApplicationAddress;
public IntPtr dwActiveProcessorMask;
public uint dwNumberOfProcessors;
public uint dwProcessorType;
public uint dwAllocationGranularity;
public ushort dwProcessorLevel;
public ushort dwProcessorRevision;
}
[StructLayout(LayoutKind.Explicit)]
public struct _PROCESSOR_INFO_UNION
{
[FieldOffset(0)]
internal uint dwOemId;
[FieldOffset(0)]
internal ushort wProcessorArchitecture;
[FieldOffset(2)]
internal ushort wReserved;
}